@rytass/wms-module-graphql 0.1.0

package/lib/resolvers/material.resolver.js

@@ -0,0 +1,84 @@
+import { __decorate, __param, __metadata } from 'tslib';
+import { ResolveField, Parent, Context, Resolver } from '@nestjs/graphql';
+import '../dto/loader-type.dto.js';
+import '../dto/loader.dto.js';
+import { MaterialDto } from '../dto/material.dto.js';
+import { MaterialUnitDto } from '../dto/material-unit.dto.js';
+import { AggregatedStockDto } from '../dto/stock.dto.js';
+import '../dto/sale-order.dto.js';
+import '../dto/receive-inventory-order.dto.js';
+import '../dto/receive-inventory-order-item.dto.js';
+import '../dto/ship-inventory-order.dto.js';
+import '../dto/ship-inventory-order-item.dto.js';
+import '../dto/hold-inventory-order.dto.js';
+import '../dto/hold-inventory-order-item.dto.js';
+import '../dto/allocate-inventory-order.dto.js';
+import '../dto/allocate-inventory-order-item.dto.js';
+import '../dto/transfer-order.dto.js';
+import '../dto/transfer-order-item.dto.js';
+import '../dto/transfer-customer-order.dto.js';
+import '../dto/transfer-customer-order-item.dto.js';
+import '../dto/transfer-vendor-order.dto.js';
+import '../dto/transfer-vendor-order-item.dto.js';
+import '../dto/scrape-order.dto.js';
+import '../dto/scrape-order-item.dto.js';
+import '../dto/quality-inspection-order.dto.js';
+import '../dto/quality-inspection-order-item.dto.js';
+import { MaterialEntityClass, StockService, MaterialUnitEntityClass, UnitEntityClass } from '@rytass/wms-module-core';
+import { UnitDto } from '../dto/unit.dto.js';
+
+let MaterialResolver = class MaterialResolver {
+    stockService;
+    constructor(stockService) {
+        this.stockService = stockService;
+    }
+    async aggregatedStock({ id }) {
+        // TODO: should be compatible with dataloader in the future
+        const [items] = await this.stockService.findAggregatedStocks({
+            materialId: id,
+            aggregated: true,
+        });
+        return items;
+    }
+    materialUnits({ id }, { loaders }) {
+        return loaders.batchMany.load({
+            __entity: MaterialUnitEntityClass,
+            __from: { materialId: id },
+        });
+    }
+    async baseUnit({ baseUnit }, { loaders }) {
+        return loaders.batchSingle.load({
+            __entity: UnitEntityClass,
+            __from: { id: baseUnit },
+        });
+    }
+};
+__decorate([
+    ResolveField(() => [AggregatedStockDto]),
+    __param(0, Parent()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [MaterialEntityClass]),
+    __metadata("design:returntype", Promise)
+], MaterialResolver.prototype, "aggregatedStock", null);
+__decorate([
+    ResolveField(() => [MaterialUnitDto]),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [MaterialEntityClass, Object]),
+    __metadata("design:returntype", void 0)
+], MaterialResolver.prototype, "materialUnits", null);
+__decorate([
+    ResolveField(() => UnitDto),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [MaterialEntityClass, Object]),
+    __metadata("design:returntype", Promise)
+], MaterialResolver.prototype, "baseUnit", null);
+MaterialResolver = __decorate([
+    Resolver(() => MaterialDto),
+    __metadata("design:paramtypes", [StockService])
+], MaterialResolver);
+
+export { MaterialResolver };

package/lib/resolvers/merge-batch.resolver.d.ts

@@ -0,0 +1,6 @@
+import { MergeBatchOrderDto, MergeBatchOrderItemDto } from '../dto/merge-batch-order.dto';
+import { MergeBatchOrderItemEntityClass } from '@rytass/wms-module-core';
+import { type LoaderType } from '../helpers';
+export declare class MergeBatchOrderResolver {
+    items({ id }: MergeBatchOrderDto, { loaders }: LoaderType<MergeBatchOrderItemEntityClass>): Promise<MergeBatchOrderItemDto[]>;
+}

package/lib/resolvers/merge-batch.resolver.js

@@ -0,0 +1,26 @@
+import { __decorate, __param, __metadata } from 'tslib';
+import { ResolveField, Parent, Context, Resolver } from '@nestjs/graphql';
+import { MergeBatchOrderItemDto, MergeBatchOrderDto } from '../dto/merge-batch-order.dto.js';
+import { MergeBatchOrderItemEntityClass } from '@rytass/wms-module-core';
+
+let MergeBatchOrderResolver = class MergeBatchOrderResolver {
+    items({ id }, { loaders }) {
+        return loaders.batchMany.load({
+            __entity: MergeBatchOrderItemEntityClass,
+            __from: { orderId: id },
+        });
+    }
+};
+__decorate([
+    ResolveField(() => [MergeBatchOrderItemDto]),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [MergeBatchOrderDto, Object]),
+    __metadata("design:returntype", Promise)
+], MergeBatchOrderResolver.prototype, "items", null);
+MergeBatchOrderResolver = __decorate([
+    Resolver(() => MergeBatchOrderDto)
+], MergeBatchOrderResolver);
+
+export { MergeBatchOrderResolver };

package/lib/resolvers/receive-inventory-order.resolver.d.ts

@@ -0,0 +1,15 @@
+import { LoaderDto, MaterialDto, ReceiveInventoryOrderDto, ReceiveInventoryOrderItemDto } from '../dto';
+import { type LoaderType } from '../helpers';
+import { BatchEntityClass, LoadersEntityClass, LocationEntityClass, MaterialEntityClass, ReceiveInventoryOrderChangeEntityClass, ReceiveInventoryOrderItemEntityClass } from '@rytass/wms-module-core';
+import { BatchDto } from '../dto/batch.dto';
+import { LocationDto } from '../dto/location.dto';
+export declare class ReceiveInventoryOrderResolver {
+    items({ id }: ReceiveInventoryOrderDto, { loaders }: LoaderType<ReceiveInventoryOrderItemEntityClass>): Promise<ReceiveInventoryOrderItemDto[]>;
+}
+export declare class ReceiveInventoryOrderItemResolver {
+    material({ materialId }: ReceiveInventoryOrderItemEntityClass, { loaders }: LoaderType<MaterialEntityClass>): Promise<MaterialDto>;
+    batch({ batchId }: ReceiveInventoryOrderItemEntityClass, { loaders }: LoaderType<BatchEntityClass>): Promise<BatchDto | null>;
+    location({ locationId }: ReceiveInventoryOrderItemEntityClass, { loaders }: LoaderType<LocationEntityClass>): Promise<LocationDto | null>;
+    loader({ loaderId }: ReceiveInventoryOrderItemEntityClass, { loaders }: LoaderType<LoadersEntityClass>): Promise<LoaderDto | null>;
+    receivedQuantity({ id }: ReceiveInventoryOrderItemEntityClass, { loaders }: LoaderType<ReceiveInventoryOrderChangeEntityClass>): Promise<number>;
+}

package/lib/resolvers/receive-inventory-order.resolver.js

@@ -0,0 +1,140 @@
+import { __decorate, __param, __metadata } from 'tslib';
+import { ResolveField, Parent, Context, Resolver, Int } from '@nestjs/graphql';
+import '../dto/loader-type.dto.js';
+import { LoaderDto } from '../dto/loader.dto.js';
+import { MaterialDto } from '../dto/material.dto.js';
+import '../dto/material-unit.dto.js';
+import '../dto/stock.dto.js';
+import '../dto/sale-order.dto.js';
+import { ReceiveInventoryOrderDto } from '../dto/receive-inventory-order.dto.js';
+import { ReceiveInventoryOrderItemDto } from '../dto/receive-inventory-order-item.dto.js';
+import '../dto/ship-inventory-order.dto.js';
+import '../dto/ship-inventory-order-item.dto.js';
+import '../dto/hold-inventory-order.dto.js';
+import '../dto/hold-inventory-order-item.dto.js';
+import '../dto/allocate-inventory-order.dto.js';
+import '../dto/allocate-inventory-order-item.dto.js';
+import '../dto/transfer-order.dto.js';
+import '../dto/transfer-order-item.dto.js';
+import '../dto/transfer-customer-order.dto.js';
+import '../dto/transfer-customer-order-item.dto.js';
+import '../dto/transfer-vendor-order.dto.js';
+import '../dto/transfer-vendor-order-item.dto.js';
+import '../dto/scrape-order.dto.js';
+import '../dto/scrape-order-item.dto.js';
+import '../dto/quality-inspection-order.dto.js';
+import '../dto/quality-inspection-order-item.dto.js';
+import { ReceiveInventoryOrderItemEntityClass, MaterialEntityClass, BatchEntityClass, BatchGroupEntityClass, LocationEntityClass, LoadersEntityClass, ReceiveInventoryOrderChangeEntityClass } from '@rytass/wms-module-core';
+import { BatchDto } from '../dto/batch.dto.js';
+import { LocationDto } from '../dto/location.dto.js';
+
+let ReceiveInventoryOrderResolver = class ReceiveInventoryOrderResolver {
+    items({ id }, { loaders }) {
+        return loaders.batchMany.load({
+            __entity: ReceiveInventoryOrderItemEntityClass,
+            __from: { orderId: id },
+            __conditions: (qb) => qb.orderBy('entity."serialId"', 'ASC'),
+        });
+    }
+};
+__decorate([
+    ResolveField(() => [ReceiveInventoryOrderItemDto]),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ReceiveInventoryOrderDto, Object]),
+    __metadata("design:returntype", Promise)
+], ReceiveInventoryOrderResolver.prototype, "items", null);
+ReceiveInventoryOrderResolver = __decorate([
+    Resolver(() => ReceiveInventoryOrderDto)
+], ReceiveInventoryOrderResolver);
+let ReceiveInventoryOrderItemResolver = class ReceiveInventoryOrderItemResolver {
+    material({ materialId }, { loaders }) {
+        return loaders.batchSingle.load({
+            __entity: MaterialEntityClass,
+            __from: { id: materialId },
+        });
+    }
+    async batch({ batchId }, { loaders }) {
+        if (!batchId)
+            return null;
+        const { groupId } = await loaders.batchSingle.load({
+            __entity: BatchEntityClass,
+            __from: { id: batchId },
+        });
+        return loaders.batchSingle.load({
+            __entity: BatchGroupEntityClass,
+            __from: { id: groupId },
+        });
+    }
+    async location({ locationId }, { loaders }) {
+        if (!locationId)
+            return null;
+        return loaders.batchSingle.load({
+            __entity: LocationEntityClass,
+            __from: { id: locationId },
+        });
+    }
+    async loader({ loaderId }, { loaders }) {
+        if (!loaderId)
+            return null;
+        return loaders.batchSingle.load({
+            __entity: LoadersEntityClass,
+            __from: { id: loaderId },
+        });
+    }
+    async receivedQuantity({ id }, { loaders }) {
+        const changes = await loaders.batchMany.load({
+            __entity: ReceiveInventoryOrderChangeEntityClass,
+            __from: { itemId: id },
+        });
+        return changes.reduce((acc, { quantityChanged }) => {
+            return acc + Number(quantityChanged);
+        }, 0);
+    }
+};
+__decorate([
+    ResolveField(() => MaterialDto),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ReceiveInventoryOrderItemEntityClass, Object]),
+    __metadata("design:returntype", Promise)
+], ReceiveInventoryOrderItemResolver.prototype, "material", null);
+__decorate([
+    ResolveField(() => BatchDto, { nullable: true }),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ReceiveInventoryOrderItemEntityClass, Object]),
+    __metadata("design:returntype", Promise)
+], ReceiveInventoryOrderItemResolver.prototype, "batch", null);
+__decorate([
+    ResolveField(() => LocationDto, { nullable: true }),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ReceiveInventoryOrderItemEntityClass, Object]),
+    __metadata("design:returntype", Promise)
+], ReceiveInventoryOrderItemResolver.prototype, "location", null);
+__decorate([
+    ResolveField(() => LoaderDto, { nullable: true }),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ReceiveInventoryOrderItemEntityClass, Object]),
+    __metadata("design:returntype", Promise)
+], ReceiveInventoryOrderItemResolver.prototype, "loader", null);
+__decorate([
+    ResolveField(() => Int),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ReceiveInventoryOrderItemEntityClass, Object]),
+    __metadata("design:returntype", Promise)
+], ReceiveInventoryOrderItemResolver.prototype, "receivedQuantity", null);
+ReceiveInventoryOrderItemResolver = __decorate([
+    Resolver(() => ReceiveInventoryOrderItemDto)
+], ReceiveInventoryOrderItemResolver);
+
+export { ReceiveInventoryOrderItemResolver, ReceiveInventoryOrderResolver };

package/lib/resolvers/ship-inventory-order.resolver.d.ts

@@ -0,0 +1,25 @@
+import { LoaderDto, MaterialDto, ShipInventoryOrderItemDto } from '../dto';
+import { BatchEntityClass, LoadersEntityClass, LocationEntityClass, MaterialEntityClass, ShipInventoryOrderChangeEntityClass, ShipInventoryOrderEntityClass, ShipInventoryOrderItemEntityClass, ShipInventoryOrderReferenceEntityClass } from '@rytass/wms-module-core';
+import { type LoaderType } from '../helpers';
+import { BatchDto } from '../dto/batch.dto';
+import { LocationDto } from '../dto/location.dto';
+import { ShipInventoryOrderReferenceDto } from '../dto/ship-inventory-order-reference.dto';
+export declare class ShipInventoryOrderResolver {
+    items({ id }: ShipInventoryOrderEntityClass, { loaders }: LoaderType<ShipInventoryOrderItemEntityClass>): Promise<ShipInventoryOrderItemDto[]>;
+    references({ id }: ShipInventoryOrderEntityClass, { loaders }: LoaderType<ShipInventoryOrderReferenceEntityClass>): Promise<ShipInventoryOrderReferenceDto[]>;
+}
+export declare class ShipInventoryOrderItemResolver {
+    material({ materialId }: ShipInventoryOrderItemEntityClass, { loaders }: LoaderType<MaterialEntityClass>): Promise<MaterialDto>;
+    batch({ batchId }: ShipInventoryOrderItemEntityClass, { loaders }: LoaderType<BatchEntityClass>): Promise<BatchDto | null>;
+    saleId({ batchId }: ShipInventoryOrderItemEntityClass, { loaders }: LoaderType<BatchEntityClass>): Promise<string | null>;
+    saleSerialId({ batchId }: ShipInventoryOrderItemEntityClass, { loaders }: LoaderType<BatchEntityClass>): Promise<string | null>;
+    location({ locationId }: ShipInventoryOrderItemEntityClass, { loaders }: LoaderType<LocationEntityClass>): Promise<LocationDto | null>;
+    loader({ loaderId }: ShipInventoryOrderItemEntityClass, { loaders }: LoaderType<LoadersEntityClass>): Promise<LoaderDto | null>;
+    shippedQuantity({ id }: ShipInventoryOrderItemEntityClass, { loaders }: LoaderType<ShipInventoryOrderChangeEntityClass>): Promise<number>;
+}
+export declare class ShipInventoryOrderReferenceResolver {
+    shippedQuantity({ orderId, serialId }: ShipInventoryOrderReferenceEntityClass, { loaders }: LoaderType<ShipInventoryOrderItemEntityClass>): Promise<number>;
+    material({ materialId }: ShipInventoryOrderReferenceEntityClass, { loaders }: LoaderType<MaterialEntityClass>): Promise<MaterialDto>;
+    batch({ batchId }: ShipInventoryOrderReferenceEntityClass, { loaders }: LoaderType<BatchEntityClass>): Promise<BatchDto | null>;
+    items({ orderId, serialId }: ShipInventoryOrderReferenceEntityClass, { loaders }: LoaderType<ShipInventoryOrderItemEntityClass>): Promise<ShipInventoryOrderItemDto[]>;
+}

package/lib/resolvers/ship-inventory-order.resolver.js

@@ -0,0 +1,273 @@
+import { __decorate, __param, __metadata } from 'tslib';
+import { ResolveField, Parent, Context, Resolver, ID, Int } from '@nestjs/graphql';
+import '../dto/loader-type.dto.js';
+import { LoaderDto } from '../dto/loader.dto.js';
+import { MaterialDto } from '../dto/material.dto.js';
+import '../dto/material-unit.dto.js';
+import '../dto/stock.dto.js';
+import '../dto/sale-order.dto.js';
+import '../dto/receive-inventory-order.dto.js';
+import '../dto/receive-inventory-order-item.dto.js';
+import { ShipInventoryOrderDto } from '../dto/ship-inventory-order.dto.js';
+import { ShipInventoryOrderItemDto } from '../dto/ship-inventory-order-item.dto.js';
+import '../dto/hold-inventory-order.dto.js';
+import '../dto/hold-inventory-order-item.dto.js';
+import '../dto/allocate-inventory-order.dto.js';
+import '../dto/allocate-inventory-order-item.dto.js';
+import '../dto/transfer-order.dto.js';
+import '../dto/transfer-order-item.dto.js';
+import '../dto/transfer-customer-order.dto.js';
+import '../dto/transfer-customer-order-item.dto.js';
+import '../dto/transfer-vendor-order.dto.js';
+import '../dto/transfer-vendor-order-item.dto.js';
+import '../dto/scrape-order.dto.js';
+import '../dto/scrape-order-item.dto.js';
+import '../dto/quality-inspection-order.dto.js';
+import '../dto/quality-inspection-order-item.dto.js';
+import { ShipInventoryOrderEntityClass, ShipInventoryOrderItemEntityClass, ShipInventoryOrderReferenceEntityClass, MaterialEntityClass, BatchEntityClass, BatchGroupEntityClass, LocationEntityClass, LoadersEntityClass, ShipInventoryOrderChangeEntityClass } from '@rytass/wms-module-core';
+import { BatchDto } from '../dto/batch.dto.js';
+import { LocationDto } from '../dto/location.dto.js';
+import { ShipInventoryOrderReferenceDto } from '../dto/ship-inventory-order-reference.dto.js';
+
+let ShipInventoryOrderResolver = class ShipInventoryOrderResolver {
+    items({ id }, { loaders }) {
+        return loaders.batchMany.load({
+            __entity: ShipInventoryOrderItemEntityClass,
+            __from: { orderId: id },
+        });
+    }
+    references({ id }, { loaders }) {
+        return loaders.batchMany.load({
+            __entity: ShipInventoryOrderReferenceEntityClass,
+            __from: { orderId: id },
+            __conditions: (qb) => qb.orderBy('entity."serialId"', 'ASC'),
+        });
+    }
+};
+__decorate([
+    ResolveField(() => [ShipInventoryOrderItemDto]),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ShipInventoryOrderEntityClass, Object]),
+    __metadata("design:returntype", Promise)
+], ShipInventoryOrderResolver.prototype, "items", null);
+__decorate([
+    ResolveField(() => [ShipInventoryOrderReferenceDto]),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ShipInventoryOrderEntityClass, Object]),
+    __metadata("design:returntype", Promise)
+], ShipInventoryOrderResolver.prototype, "references", null);
+ShipInventoryOrderResolver = __decorate([
+    Resolver(() => ShipInventoryOrderDto)
+], ShipInventoryOrderResolver);
+let ShipInventoryOrderItemResolver = class ShipInventoryOrderItemResolver {
+    material({ materialId }, { loaders }) {
+        return loaders.batchSingle.load({
+            __entity: MaterialEntityClass,
+            __from: { id: materialId },
+        });
+    }
+    async batch({ batchId }, { loaders }) {
+        if (!batchId)
+            return null;
+        const { groupId } = await loaders.batchSingle.load({
+            __entity: BatchEntityClass,
+            __from: { id: batchId },
+        });
+        return loaders.batchSingle.load({
+            __entity: BatchGroupEntityClass,
+            __from: { id: groupId },
+        });
+    }
+    async saleId({ batchId }, { loaders }) {
+        if (!batchId)
+            return null;
+        const { groupId } = await loaders.batchSingle.load({
+            __entity: BatchEntityClass,
+            __from: { id: batchId },
+        });
+        return loaders.batchSingle
+            .load({
+            __entity: BatchGroupEntityClass,
+            __from: { id: groupId },
+        })
+            .then(({ saleId }) => saleId);
+    }
+    async saleSerialId({ batchId }, { loaders }) {
+        if (!batchId)
+            return null;
+        const { groupId } = await loaders.batchSingle.load({
+            __entity: BatchEntityClass,
+            __from: { id: batchId },
+        });
+        return loaders.batchSingle
+            .load({
+            __entity: BatchGroupEntityClass,
+            __from: { id: groupId },
+        })
+            .then(({ saleSerialId }) => saleSerialId);
+    }
+    async location({ locationId }, { loaders }) {
+        if (!locationId)
+            return null;
+        return loaders.batchSingle.load({
+            __entity: LocationEntityClass,
+            __from: { id: locationId },
+        });
+    }
+    async loader({ loaderId }, { loaders }) {
+        if (!loaderId)
+            return null;
+        return loaders.batchSingle.load({
+            __entity: LoadersEntityClass,
+            __from: { id: loaderId },
+        });
+    }
+    async shippedQuantity({ id }, { loaders }) {
+        const changes = await loaders.batchMany.load({
+            __entity: ShipInventoryOrderChangeEntityClass,
+            __from: { itemId: id },
+        });
+        return changes.reduce((acc, { quantityChanged }) => {
+            const qty = Number(quantityChanged);
+            return qty < 0 ? acc + Math.abs(qty) : acc;
+        }, 0);
+    }
+};
+__decorate([
+    ResolveField(() => MaterialDto),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ShipInventoryOrderItemEntityClass, Object]),
+    __metadata("design:returntype", Promise)
+], ShipInventoryOrderItemResolver.prototype, "material", null);
+__decorate([
+    ResolveField(() => BatchDto, { nullable: true }),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ShipInventoryOrderItemEntityClass, Object]),
+    __metadata("design:returntype", Promise)
+], ShipInventoryOrderItemResolver.prototype, "batch", null);
+__decorate([
+    ResolveField(() => ID, { nullable: true }),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ShipInventoryOrderItemEntityClass, Object]),
+    __metadata("design:returntype", Promise)
+], ShipInventoryOrderItemResolver.prototype, "saleId", null);
+__decorate([
+    ResolveField(() => ID, { nullable: true }),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ShipInventoryOrderItemEntityClass, Object]),
+    __metadata("design:returntype", Promise)
+], ShipInventoryOrderItemResolver.prototype, "saleSerialId", null);
+__decorate([
+    ResolveField(() => LocationDto, { nullable: true }),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ShipInventoryOrderItemEntityClass, Object]),
+    __metadata("design:returntype", Promise)
+], ShipInventoryOrderItemResolver.prototype, "location", null);
+__decorate([
+    ResolveField(() => LoaderDto, { nullable: true }),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ShipInventoryOrderItemEntityClass, Object]),
+    __metadata("design:returntype", Promise)
+], ShipInventoryOrderItemResolver.prototype, "loader", null);
+__decorate([
+    ResolveField(() => Int),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ShipInventoryOrderItemEntityClass, Object]),
+    __metadata("design:returntype", Promise)
+], ShipInventoryOrderItemResolver.prototype, "shippedQuantity", null);
+ShipInventoryOrderItemResolver = __decorate([
+    Resolver(() => ShipInventoryOrderItemDto)
+], ShipInventoryOrderItemResolver);
+let ShipInventoryOrderReferenceResolver = class ShipInventoryOrderReferenceResolver {
+    async shippedQuantity({ orderId, serialId }, { loaders }) {
+        const items = await loaders.batchMany.load({
+            __entity: ShipInventoryOrderItemEntityClass,
+            __from: { orderId, serialId },
+            __conditions: (qb) => qb.leftJoinAndSelect('entity.changes', 'changes'),
+        });
+        const changes = items.flatMap((item) => item.changes);
+        return changes.reduce((acc, { quantityChanged }) => {
+            const qty = Number(quantityChanged);
+            return qty < 0 ? acc + Math.abs(qty) : acc;
+        }, 0);
+    }
+    material({ materialId }, { loaders }) {
+        return loaders.batchSingle.load({
+            __entity: MaterialEntityClass,
+            __from: { id: materialId },
+        });
+    }
+    async batch({ batchId }, { loaders }) {
+        if (!batchId)
+            return null;
+        const { groupId } = await loaders.batchSingle.load({
+            __entity: BatchEntityClass,
+            __from: { id: batchId },
+        });
+        return loaders.batchSingle.load({
+            __entity: BatchGroupEntityClass,
+            __from: { id: groupId },
+        });
+    }
+    async items({ orderId, serialId }, { loaders }) {
+        return loaders.batchMany.load({
+            __entity: ShipInventoryOrderItemEntityClass,
+            __from: { orderId, serialId },
+        });
+    }
+};
+__decorate([
+    ResolveField(() => Int),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ShipInventoryOrderReferenceEntityClass, Object]),
+    __metadata("design:returntype", Promise)
+], ShipInventoryOrderReferenceResolver.prototype, "shippedQuantity", null);
+__decorate([
+    ResolveField(() => MaterialDto),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ShipInventoryOrderReferenceEntityClass, Object]),
+    __metadata("design:returntype", Promise)
+], ShipInventoryOrderReferenceResolver.prototype, "material", null);
+__decorate([
+    ResolveField(() => BatchDto, { nullable: true }),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ShipInventoryOrderReferenceEntityClass, Object]),
+    __metadata("design:returntype", Promise)
+], ShipInventoryOrderReferenceResolver.prototype, "batch", null);
+__decorate([
+    ResolveField(() => [ShipInventoryOrderItemDto]),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ShipInventoryOrderReferenceEntityClass, Object]),
+    __metadata("design:returntype", Promise)
+], ShipInventoryOrderReferenceResolver.prototype, "items", null);
+ShipInventoryOrderReferenceResolver = __decorate([
+    Resolver(() => ShipInventoryOrderReferenceDto)
+], ShipInventoryOrderReferenceResolver);
+
+export { ShipInventoryOrderItemResolver, ShipInventoryOrderReferenceResolver, ShipInventoryOrderResolver };

package/lib/resolvers/split-batch.resolver.d.ts

@@ -0,0 +1,6 @@
+import { SplitBatchOrderDto, SplitBatchOrderItemDto } from '../dto/split-batch-order.dto';
+import { type LoaderType } from '../helpers';
+import { SplitBatchOrderItemEntityClass } from '@rytass/wms-module-core';
+export declare class SplitBatchResolver {
+    items({ id }: SplitBatchOrderDto, { loaders }: LoaderType<SplitBatchOrderItemEntityClass>): Promise<SplitBatchOrderItemDto[]>;
+}

package/lib/resolvers/split-batch.resolver.js

@@ -0,0 +1,26 @@
+import { __decorate, __param, __metadata } from 'tslib';
+import { ResolveField, Parent, Context, Resolver } from '@nestjs/graphql';
+import { SplitBatchOrderItemDto, SplitBatchOrderDto } from '../dto/split-batch-order.dto.js';
+import { SplitBatchOrderItemEntityClass } from '@rytass/wms-module-core';
+
+let SplitBatchResolver = class SplitBatchResolver {
+    items({ id }, { loaders }) {
+        return loaders.batchMany.load({
+            __entity: SplitBatchOrderItemEntityClass,
+            __from: { orderId: id },
+        });
+    }
+};
+__decorate([
+    ResolveField(() => [SplitBatchOrderItemDto]),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [SplitBatchOrderDto, Object]),
+    __metadata("design:returntype", Promise)
+], SplitBatchResolver.prototype, "items", null);
+SplitBatchResolver = __decorate([
+    Resolver(() => SplitBatchOrderDto)
+], SplitBatchResolver);
+
+export { SplitBatchResolver };

package/lib/resolvers/stock.resolver.d.ts

@@ -0,0 +1,10 @@
+import { MaterialDto } from '../dto';
+import { BatchEntityClass, LocationEntityClass, MaterialEntityClass, StockEntityClass } from '@rytass/wms-module-core';
+import { type LoaderType } from '../helpers';
+import { LocationDto } from '../dto/location.dto';
+import { BatchDto } from '../dto/batch.dto';
+export declare class StockResolver {
+    material({ materialId }: StockEntityClass, { loaders }: LoaderType<MaterialEntityClass>): Promise<MaterialDto>;
+    location({ locationId }: StockEntityClass, { loaders }: LoaderType<LocationEntityClass>): Promise<LocationDto>;
+    batch({ batchId }: StockEntityClass, { loaders }: LoaderType<BatchEntityClass>): Promise<BatchDto | null>;
+}