@rytass/wms-module-core 0.1.0

package/lib/services/stock.service.js

@@ -0,0 +1,477 @@
+import { __decorate, __param, __metadata } from 'tslib';
+import { Injectable, Inject } from '@nestjs/common';
+import { StockEntity } from '../models/metadata/stock.entity.js';
+import { DataSource } from 'typeorm';
+import { MaterialEntity, MaterialEntityClass } from '../models/metadata/material.entity.js';
+import { StockStatus, ChangeType } from '../constants/stock-status.js';
+import { BatchEntity } from '@rytass/wms-base-nestjs-module';
+import '../models/metadata/batch.entity.js';
+import '../models/metadata/batch-group.entity.js';
+import { LoadersEntityClass } from '../models/metadata/loader.entity.js';
+import { LoaderTypeEntityClass } from '../models/metadata/loader-type.entity.js';
+import '../models/metadata/loader-unit.entity.js';
+import { LocationEntityClass } from '../models/metadata/location.entity.js';
+import '../models/metadata/material-unit.entity.js';
+import '../models/metadata/sale-order.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';
+import { WMS_CORE_MODULE_OPTIONS } from '../typings/core-module-options.js';
+
+let StockService = class StockService {
+    dataSource;
+    stockEntity;
+    materialEntity;
+    coreOptions;
+    defaultLoaderId;
+    defaultLocationId;
+    stockRepository;
+    selectQueryBuilder;
+    aggregateKeys = ['materialId', 'batchId', 'locationId', 'loaderId', 'status'];
+    generatedAggregateKey = (aggregated) => {
+        return this.aggregateKeys.map((key) => aggregated[key]).join('|');
+    };
+    destructAggregateKey = (key) => {
+        const [materialId, batchId, locationId, loaderId, status] = key.split('|');
+        return {
+            materialId,
+            batchId,
+            locationId,
+            loaderId,
+            status: status,
+        };
+    };
+    constructor(dataSource, stockEntity, materialEntity, coreOptions) {
+        this.dataSource = dataSource;
+        this.stockEntity = stockEntity;
+        this.materialEntity = materialEntity;
+        this.coreOptions = coreOptions;
+        this.stockRepository = this.dataSource.getRepository(this.stockEntity);
+        // select builder for status and quantity calculation, calculated field will override fields in stock entity.
+        // every query should use this selectQueryBuilder to ensure status and quantity are correct
+        // status is resolved from batch flags: inShipment → IN_SHIPMENT, held → HELD, inTransfer → IN_TRANSFER, else → FREE
+        this.selectQueryBuilder = (alias, qb = this.dataSource
+            .getRepository(this.stockEntity)
+            .createQueryBuilder(alias)) => qb
+            .leftJoin((subQuery) => subQuery
+            .select(`CASE
+                  WHEN b."inShipment" = true THEN '${StockStatus.IN_SHIPMENT}'
+                  WHEN b."held" = true THEN '${StockStatus.HELD}'
+                  WHEN b."transferId" IS NOT NULL THEN '${StockStatus.IN_TRANSFER}'
+                  ELSE '${StockStatus.FREE}'
+                END`, 'status')
+            .addSelect('s.id', 'stockId')
+            .addSelect('b."transferId"', 'transferId')
+            .addSelect('b."held"', 'held')
+            .addSelect('b."inShipment"', 'inShipment')
+            .addSelect('b."inspectionResult"', 'inspectionResult')
+            .addSelect('b."saleId"', 'saleId')
+            .addSelect('b."vendorId"', 'vendorId')
+            .addSelect('b."customerId"', 'customerId')
+            .from('stocks', 's')
+            .innerJoin('batches', 'b', 's."batchId" = b.id'), 'stock_status', `stock_status."stockId" = ${alias}.id`)
+            .addSelect('stock_status.status', 'status')
+            .addSelect('stock_status."transferId"', 'transferId')
+            .addSelect('stock_status.held', 'held')
+            .addSelect('stock_status."inShipment"', 'inShipment')
+            .addSelect('stock_status."inspectionResult"', 'inspectionResult')
+            .addSelect('stock_status."saleId"', 'saleId')
+            .addSelect('stock_status."vendorId"', 'vendorId')
+            .addSelect('stock_status."customerId"', 'customerId')
+            .addSelect(`${alias}.*`);
+    }
+    async onModuleInit() {
+        const loaderTypeRepo = this.dataSource.getRepository(LoaderTypeEntityClass);
+        const locationRepo = this.dataSource.getRepository(LocationEntityClass);
+        const loaderRepo = this.dataSource.getRepository(LoadersEntityClass);
+        // Ensure default loader type exists
+        let loaderType = await loaderTypeRepo.findOneBy({
+            key: this.coreOptions.defaultLoaderTypeKey,
+        });
+        if (!loaderType) {
+            loaderType = await loaderTypeRepo.save(loaderTypeRepo.create({
+                key: this.coreOptions.defaultLoaderTypeKey,
+                description: this.coreOptions.defaultLoaderTypeKey,
+            }));
+        }
+        // Ensure default location exists
+        let location = await locationRepo.findOneBy({
+            key: this.coreOptions.defaultLocationKey,
+        });
+        if (!location) {
+            location = await locationRepo.save(locationRepo.create({
+                key: this.coreOptions.defaultLocationKey,
+                description: this.coreOptions.defaultLocationKey,
+            }));
+        }
+        this.defaultLocationId = location.id;
+        // Ensure default loader exists
+        let loader = await loaderRepo.findOneBy({
+            serialId: this.coreOptions.defaultLoaderSerialId,
+        });
+        if (!loader) {
+            loader = await loaderRepo.save(loaderRepo.create({
+                serialId: this.coreOptions.defaultLoaderSerialId,
+                typeId: loaderType.id,
+                locationId: location.id,
+            }));
+        }
+        this.defaultLoaderId = loader.id;
+    }
+    resolveLoaderId(loaderId) {
+        return loaderId || this.defaultLoaderId;
+    }
+    resolveLocationId(locationId) {
+        return locationId || this.defaultLocationId;
+    }
+    pipeSelectOptionsToQueryBuilder(options, queryBuilder, aggregated = false) {
+        if (options.materialId)
+            queryBuilder.andWhere('stock."materialId" = :materialId', {
+                materialId: options.materialId,
+            });
+        if (options.batchId)
+            queryBuilder.andWhere('stock."batchId" = :batchId', {
+                batchId: options.batchId,
+            });
+        if (options.locationId)
+            queryBuilder.andWhere('stock."locationId" = :locationId', {
+                locationId: options.locationId,
+            });
+        if (options.loaderId)
+            queryBuilder.andWhere('stock."loaderId" = :loaderId', {
+                loaderId: options.loaderId,
+            });
+        if (options.description)
+            queryBuilder.andWhere('stock."description" ILIKE :description', {
+                description: `%${options.description}%`,
+            });
+        if (options.wildcard) {
+            const { key, value } = options.wildcard;
+            queryBuilder.andWhere(`location."${String(key)}" ILIKE :value`, {
+                value: `%${value}%`,
+            });
+        }
+        if (options.status) {
+            switch (options.status) {
+                case StockStatus.PENDING_INSPECTION:
+                    queryBuilder.andWhere('stock_status."inspectionResult" IS NULL');
+                    break;
+                case StockStatus.INSPECTION_FAILED:
+                    queryBuilder.andWhere('stock_status."inspectionResult" = false');
+                    break;
+                case StockStatus.ALLOCATED:
+                    queryBuilder.andWhere('stock_status."saleId" IS NOT NULL');
+                    break;
+                case StockStatus.VENDOR_INVENTORY:
+                    queryBuilder.andWhere('stock_status."vendorId" IS NOT NULL');
+                    break;
+                case StockStatus.CUSTOMER_INVENTORY:
+                    queryBuilder.andWhere('stock_status."customerId" IS NOT NULL');
+                    break;
+                default:
+                    queryBuilder.andWhere('stock_status.status = :status', {
+                        status: options.status,
+                    });
+                    break;
+            }
+        }
+        if (options.negateStatus) {
+            switch (options.negateStatus) {
+                case StockStatus.PENDING_INSPECTION:
+                    queryBuilder.andWhere('stock_status."inspectionResult" IS NOT NULL');
+                    break;
+                case StockStatus.INSPECTION_FAILED:
+                    queryBuilder.andWhere('(stock_status."inspectionResult" IS NULL OR stock_status."inspectionResult" != false)');
+                    break;
+                case StockStatus.ALLOCATED:
+                    queryBuilder.andWhere('stock_status."saleId" IS NULL');
+                    break;
+                case StockStatus.VENDOR_INVENTORY:
+                    queryBuilder.andWhere('stock_status."vendorId" IS NULL');
+                    break;
+                case StockStatus.CUSTOMER_INVENTORY:
+                    queryBuilder.andWhere('stock_status."customerId" IS NULL');
+                    break;
+                default:
+                    queryBuilder.andWhere('stock_status.status != :negateStatus', {
+                        negateStatus: options.negateStatus,
+                    });
+                    break;
+            }
+        }
+        if (options.materialKey)
+            queryBuilder.innerJoin(MaterialEntityClass, 'mk', 'mk.id = stock."materialId" AND mk.key ILIKE :materialKey', {
+                materialKey: `%${options.materialKey}%`,
+            });
+        if (options.batchKey)
+            queryBuilder.innerJoin(BatchEntity, 'bk', 'bk.id = stock."batchId" AND bk.key ILIKE :batchKey', {
+                batchKey: `%${options.batchKey}%`,
+            });
+        if (options.locationKey)
+            queryBuilder.innerJoin(LocationEntityClass, 'lk', 'lk.id = stock."locationId" AND lk.key ILIKE :locationKey', {
+                locationKey: `%${options.locationKey}%`,
+            });
+        if (options.loaderKey)
+            queryBuilder.innerJoin(LoadersEntityClass, 'lk', 'lk.id = stock."loaderId" AND lk."serialId" ILIKE :loaderKey', {
+                loaderKey: `%${options.loaderKey}%`,
+            });
+        if (options.offset !== undefined && options.offset >= 0)
+            queryBuilder.skip(options.offset);
+        if (options.limit !== undefined && options.limit > 0)
+            queryBuilder.take(options.limit);
+        if (aggregated) {
+            queryBuilder.innerJoin('batches', 'b', 'stock."batchId" = b.id');
+            queryBuilder.select('stock."materialId"', 'materialId');
+            queryBuilder.addSelect('stock."batchId"', 'batchId');
+            queryBuilder.addSelect('stock."locationId"', 'locationId');
+            queryBuilder.addSelect('stock."loaderId"', 'loaderId');
+            queryBuilder.addSelect('stock_status.status', 'status');
+            queryBuilder.addSelect('stock_status."transferId"', 'transferId');
+            queryBuilder.addSelect('stock_status."held"', 'held');
+            queryBuilder.addSelect('stock_status."inShipment"', 'inShipment');
+            queryBuilder.addSelect('b."saleId"', 'saleId');
+            queryBuilder.addSelect('b."saleSerialId"', 'saleSerialId');
+            queryBuilder.addSelect('b."customerId"', 'customerId');
+            queryBuilder.addSelect('b."vendorId"', 'vendorId');
+            queryBuilder.addSelect('b."inspectionResult"', 'inspectionResult');
+            queryBuilder.addSelect('SUM(stock.quantity)', 'quantity');
+            queryBuilder.groupBy('stock."materialId"');
+            queryBuilder.addGroupBy('stock."batchId"');
+            queryBuilder.addGroupBy('stock."locationId"');
+            queryBuilder.addGroupBy('stock."loaderId"');
+            queryBuilder.addGroupBy('stock_status.status');
+            queryBuilder.addGroupBy('stock_status."transferId"');
+            queryBuilder.addGroupBy('stock_status."held"');
+            queryBuilder.addGroupBy('stock_status."inShipment"');
+            queryBuilder.addGroupBy('b."saleId"');
+            queryBuilder.addGroupBy('b."saleSerialId"');
+            queryBuilder.addGroupBy('b."customerId"');
+            queryBuilder.addGroupBy('b."vendorId"');
+            queryBuilder.addGroupBy('b."inspectionResult"');
+            queryBuilder.having('SUM(stock.quantity) <> 0');
+            if (options.aggregatedKeys?.length)
+                queryBuilder.andHaving([
+                    'stock."materialId"',
+                    'stock."batchId"',
+                    'stock."locationId"',
+                    'stock."loaderId"',
+                    'stock_status.status',
+                ].join(" || '|' || ") + ' IN (:...aggregatedKeys)', {
+                    aggregatedKeys: options.aggregatedKeys,
+                });
+        }
+        return queryBuilder;
+    }
+    findMany(options) {
+        const queryBuilder = this.pipeSelectOptionsToQueryBuilder(options, this.selectQueryBuilder('stock'));
+        return queryBuilder.getManyAndCount();
+    }
+    async findManyGroupedByMaterialId(options) {
+        // Build aggregated subquery to get distinct materialIds where SUM(quantity) != 0
+        const aggregateSubquery = this.pipeSelectOptionsToQueryBuilder({ ...options, offset: undefined, limit: undefined }, this.selectQueryBuilder('stock'), true);
+        const rawMaterialIds = await this.dataSource
+            .createQueryBuilder()
+            .select('DISTINCT agg."materialId"', 'materialId')
+            .from(`(${aggregateSubquery.getQuery()})`, 'agg')
+            .setParameters(aggregateSubquery.getParameters())
+            .getRawMany();
+        const ids = rawMaterialIds.map((r) => r.materialId);
+        if (ids.length === 0)
+            return [[], 0];
+        const queryBuilder = this.dataSource
+            .getRepository(this.materialEntity)
+            .createQueryBuilder('material')
+            .where('material.id IN (:...materialIds)', { materialIds: ids });
+        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();
+    }
+    async findAggregatedStock(options, manager = this.dataSource.manager) {
+        const queryBuilder = this.pipeSelectOptionsToQueryBuilder(options, this.selectQueryBuilder('stock', manager.getRepository(this.stockEntity).createQueryBuilder('stock')), true);
+        return queryBuilder.getRawOne();
+    }
+    async validateStockAvailability(params, manager = this.dataSource.manager) {
+        const { materialId, batchId, locationId, loaderId, quantity } = params;
+        const aggregateQuery = this.pipeSelectOptionsToQueryBuilder({ materialId, batchId, locationId, loaderId }, this.selectQueryBuilder('stock', manager.getRepository(this.stockEntity).createQueryBuilder('stock')), true);
+        const result = await manager
+            .createQueryBuilder()
+            .select('COALESCE(SUM(agg.quantity), 0)', 'total')
+            .from(`(${aggregateQuery.getQuery()})`, 'agg')
+            .setParameters(aggregateQuery.getParameters())
+            .getRawOne();
+        const available = parseFloat(result?.total ?? '0');
+        if (available < quantity) {
+            throw new Error(`Insufficient stock: available ${available}, requested ${quantity} (materialId=${materialId}, batchId=${batchId}, loaderId=${loaderId})`);
+        }
+    }
+    async findAggregatedStocks(options) {
+        // Create the aggregated subquery without pagination
+        const aggregateSubquery = this.pipeSelectOptionsToQueryBuilder({ ...options, offset: undefined, limit: undefined }, this.selectQueryBuilder('stock'), options.aggregated ? true : false);
+        // Wrap the aggregated subquery and apply pagination on top
+        const paginatedQueryBuilder = this.dataSource
+            .createQueryBuilder()
+            .addSelect('agg.quantity', 'quantity')
+            .from(`(${aggregateSubquery.getQuery()})`, 'agg')
+            .setParameters(aggregateSubquery.getParameters());
+        this.aggregateKeys.forEach((key) => paginatedQueryBuilder.addSelect(`agg."${key}"`, key));
+        // Add batch-related fields
+        paginatedQueryBuilder.addSelect('agg."transferId"', 'transferId');
+        paginatedQueryBuilder.addSelect('agg."held"', 'held');
+        paginatedQueryBuilder.addSelect('agg."inShipment"', 'inShipment');
+        paginatedQueryBuilder.addSelect('agg."saleId"', 'saleId');
+        paginatedQueryBuilder.addSelect('agg."saleSerialId"', 'saleSerialId');
+        paginatedQueryBuilder.addSelect('agg."customerId"', 'customerId');
+        paginatedQueryBuilder.addSelect('agg."vendorId"', 'vendorId');
+        paginatedQueryBuilder.addSelect('agg."inspectionResult"', 'inspectionResult');
+        // Apply pagination to the outer query
+        if (options.offset !== undefined && options.offset >= 0) {
+            paginatedQueryBuilder.skip(options.offset);
+        }
+        if (options.limit !== undefined && options.limit > 0) {
+            paginatedQueryBuilder.take(options.limit);
+        }
+        // Get total count from the aggregated subquery
+        const countBuilder = this.pipeSelectOptionsToQueryBuilder({ ...options, offset: undefined, limit: undefined }, this.selectQueryBuilder('stock'), options.aggregated ? true : false);
+        const countResult = await this.dataSource
+            .createQueryBuilder()
+            .select('COUNT(*)', 'count')
+            .from(`(${countBuilder.getQuery()})`, 'grouped')
+            .setParameters(countBuilder.getParameters())
+            .getRawOne();
+        const count = parseInt(countResult?.count ?? '0', 10);
+        const items = await paginatedQueryBuilder.getRawMany();
+        return [items, count];
+    }
+    async findChangeLogs(options) {
+        // Build base query with all change entity joins
+        const changesQueryBuilder = this.pipeSelectOptionsToQueryBuilder({ ...options, offset: undefined, limit: undefined }, this.selectQueryBuilder('stock'), false)
+            .leftJoin('receive_inventory_order_changes', 'receive_change', 'stock."orderId" = receive_change.id')
+            .leftJoin('ship_inventory_order_changes', 'ship_change', 'stock."orderId" = ship_change.id')
+            .leftJoin('transfer_order_changes', 'transfer_change', 'stock."orderId" = transfer_change.id')
+            .leftJoin('transfer_vendor_order_changes', 'vendor_change', 'stock."orderId" = vendor_change.id')
+            .leftJoin('transfer_customer_order_changes', 'customer_change', 'stock."orderId" = customer_change.id')
+            .leftJoin('hold_inventory_order_changes', 'hold_change', 'stock."orderId" = hold_change.id')
+            .leftJoin('split_batch_order_changes', 'split_change', 'stock."orderId" = split_change.id')
+            .leftJoin('merge_batch_order_changes', 'merge_change', 'stock."orderId" = merge_change.id')
+            .leftJoin('allocate_inventory_order_changes', 'allocate_change', 'stock."orderId" = allocate_change.id')
+            .leftJoin('reclassify_inventory_order_changes', 'reclassify_change', 'stock."orderId" = reclassify_change.id')
+            .leftJoin('scrape_order_changes', 'scrape_change', 'stock."orderId" = scrape_change.id')
+            .andWhere(`(
+          (receive_change.id IS NOT NULL AND receive_change."quantityChanged" * stock.quantity > 0)
+          OR (ship_change.id IS NOT NULL AND ship_change."quantityChanged" * stock.quantity > 0)
+          OR (transfer_change.id IS NOT NULL AND transfer_change."quantityChanged" * stock.quantity > 0)
+          OR (vendor_change.id IS NOT NULL AND vendor_change."quantityChanged" * stock.quantity > 0)
+          OR (customer_change.id IS NOT NULL AND customer_change."quantityChanged" * stock.quantity > 0)
+          OR (hold_change.id IS NOT NULL AND hold_change."quantityChanged" * stock.quantity > 0)
+          OR (split_change.id IS NOT NULL AND split_change."quantityChanged" * stock.quantity > 0)
+          OR (merge_change.id IS NOT NULL AND merge_change."quantityChanged" * stock.quantity > 0)
+          OR (allocate_change.id IS NOT NULL AND allocate_change."quantityChanged" * stock.quantity > 0)
+          OR (reclassify_change.id IS NOT NULL AND reclassify_change."quantityChanged" * stock.quantity > 0)
+          OR (scrape_change.id IS NOT NULL AND scrape_change."quantityChanged" * stock.quantity > 0)
+        )`);
+        // Get count from the filtered base query (before adding expensive CASE)
+        const countQuerySimple = changesQueryBuilder
+            .clone()
+            .select('COUNT(DISTINCT stock.id)', 'count');
+        const countResult = await this.dataSource
+            .createQueryBuilder()
+            .select('SUM(counted.count)', 'total')
+            .from(`(${countQuerySimple.getQuery()})`, 'counted')
+            .setParameters(countQuerySimple.getParameters())
+            .getRawOne();
+        const count = parseInt(countResult?.total ?? '0', 10);
+        // Add changeType CASE only after we have the filtered result set, apply pagination
+        const resultQueryBuilder = changesQueryBuilder.clone();
+        if (options.offset !== undefined && options.offset >= 0) {
+            resultQueryBuilder.skip(options.offset);
+        }
+        if (options.limit !== undefined && options.limit > 0) {
+            resultQueryBuilder.take(options.limit);
+        }
+        // Explicitly select only the fields needed for ChangeLog
+        resultQueryBuilder
+            .select('stock.id', 'id')
+            .addSelect('stock.quantity', 'quantity')
+            .addSelect('stock_status.status', 'status')
+            .addSelect('stock."materialId"', 'materialId')
+            .addSelect('stock."batchId"', 'batchId')
+            .addSelect('stock."locationId"', 'locationId')
+            .addSelect('stock."loaderId"', 'loaderId')
+            .addSelect(`CASE
+          WHEN receive_change.id IS NOT NULL THEN '${ChangeType.RECEIVED}'
+          WHEN ship_change.id IS NOT NULL THEN
+            CASE WHEN ship_change."quantityChanged" > 0 THEN '${ChangeType.IN_SHIPMENT}'
+                 ELSE '${ChangeType.SHIPPED}' END
+          WHEN transfer_change.id IS NOT NULL THEN
+            CASE WHEN transfer_change."quantityChanged" > 0 THEN '${ChangeType.IN_TRANSFER}'
+                 ELSE '${ChangeType.TRANSFERRED}' END
+          WHEN vendor_change.id IS NOT NULL THEN
+            CASE WHEN vendor_change."quantityChanged" > 0 THEN '${ChangeType.VENDOR_TRANSFERRED}'
+                 ELSE '${ChangeType.VENDOR_RETURNED}' END
+          WHEN customer_change.id IS NOT NULL THEN
+            CASE WHEN customer_change."quantityChanged" > 0 THEN '${ChangeType.CUSTOMER_HELD}'
+                 ELSE '${ChangeType.CUSTOMER_RETURNED}' END
+          WHEN hold_change.id IS NOT NULL THEN
+            CASE WHEN hold_change."quantityChanged" > 0 THEN '${ChangeType.HELD}'
+                 ELSE '${ChangeType.RELEASED}' END
+          WHEN split_change.id IS NOT NULL THEN '${ChangeType.SPLITTED}'
+          WHEN merge_change.id IS NOT NULL THEN '${ChangeType.MERGED}'
+          WHEN allocate_change.id IS NOT NULL THEN
+            CASE WHEN allocate_change."quantityChanged" > 0 THEN '${ChangeType.ALLOCATED}'
+                 ELSE '${ChangeType.DEALLOCATED}' END
+          WHEN reclassify_change.id IS NOT NULL THEN '${ChangeType.RECLASSIFIED}'
+          WHEN scrape_change.id IS NOT NULL THEN '${ChangeType.SCRAPED}'
+          ELSE NULL
+        END`, 'changeType');
+        const items = await resultQueryBuilder
+            .addOrderBy('stock."createdAt"', 'DESC')
+            .getRawMany();
+        return [items, count];
+    }
+};
+StockService = __decorate([
+    Injectable(),
+    __param(1, Inject(StockEntity)),
+    __param(2, Inject(MaterialEntity)),
+    __param(3, Inject(WMS_CORE_MODULE_OPTIONS)),
+    __metadata("design:paramtypes", [DataSource, Object, Object, Object])
+], StockService);
+
+export { StockService };

package/lib/services/transfer-customer-order.service.d.ts

@@ -0,0 +1,35 @@
+import { TransferCustomerOrderEntityClass, TransferCustomerOrderItemEntityClass, StockEntityClass } from '../models';
+import { DataSource, EntityManager, EntityTarget } from 'typeorm';
+import { CreateTransferCustomerOrderInput, UpdateTransferCustomerOrderInput } from '../typings/create-transfer-customer-order.input';
+import { HelperService } from './helper.service';
+import { MaterialService } from './material.service';
+import { BatchService } from './batch.service';
+import { StockService } from './stock.service';
+export type TransferCustomerOrderItemInput = {
+    materialId: string;
+    batchId: string;
+    locationId?: string;
+    loaderId?: string;
+    quantity: number;
+    locationKey: string;
+    loaderKey?: string;
+};
+export declare class TransferCustomerOrderService<T extends TransferCustomerOrderEntityClass = TransferCustomerOrderEntityClass, K extends TransferCustomerOrderItemEntityClass = TransferCustomerOrderItemEntityClass> {
+    private readonly dataSource;
+    private readonly helperService;
+    private readonly materialService;
+    private readonly batchService;
+    private readonly stockService;
+    readonly transferCustomerOrderEntity: EntityTarget<T>;
+    readonly transferCustomerOrderItemEntity: EntityTarget<K>;
+    readonly stockEntity: EntityTarget<StockEntityClass>;
+    private readonly seqPrefix;
+    constructor(dataSource: DataSource, helperService: HelperService, materialService: MaterialService, batchService: BatchService, stockService: StockService, transferCustomerOrderEntity: EntityTarget<T>, transferCustomerOrderItemEntity: EntityTarget<K>, stockEntity: EntityTarget<StockEntityClass>);
+    private getRepositories;
+    private processTransferCustomerOrderItems;
+    createTransferCustomerOrder(options: CreateTransferCustomerOrderInput, manager?: EntityManager): Promise<T>;
+    updateTransferCustomerOrder({ id, manager, ...options }: UpdateTransferCustomerOrderInput & {
+        manager?: EntityManager;
+    }): Promise<T>;
+    returnTransferCustomerOrder(options: TransferCustomerOrderItemInput | TransferCustomerOrderItemInput[], manager?: EntityManager): Promise<T>;
+}