@rytass/wms-module-graphql 0.1.0

package/lib/mutations/ship-inventory-order.mutation.js

@@ -0,0 +1,107 @@
+import { __decorate, __param, __metadata } from 'tslib';
+import { Injectable } from '@nestjs/common';
+import { ShipInventoryOrderService, StockService } from '@rytass/wms-module-core';
+import '../dto/loader-type.dto.js';
+import '../dto/loader.dto.js';
+import '../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 '../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 { Mutation, Args } from '@nestjs/graphql';
+import { CreateShipInventoryOrderArgs, UpdateShipInventoryOrderArgs } from '../inputs/create-ship-inventory-order.args.js';
+import { ShipOrderArgs } from '../inputs/ship-order.args.js';
+import { CancelShipOrderArgs } from '../inputs/cancel-ship-order.args.js';
+
+let ShipInventoryOrderMutation = class ShipInventoryOrderMutation {
+    shipInventoryOrderService;
+    stockService;
+    constructor(shipInventoryOrderService, stockService) {
+        this.shipInventoryOrderService = shipInventoryOrderService;
+        this.stockService = stockService;
+    }
+    async createShipInventoryOrder(args) {
+        const { id } = await this.shipInventoryOrderService.createShipInventoryOrder(args);
+        return this.shipInventoryOrderService
+            .selectQueryBuilder('orders')
+            .where('orders.id = :id', { id })
+            .getRawOne();
+    }
+    async updateShipInventoryOrder(args) {
+        const { id } = await this.shipInventoryOrderService.updateShipInventoryOrder({
+            ...args,
+            items: args?.items?.map(({ aggregatedKey, ...item }) => {
+                const keys = aggregatedKey
+                    ? this.stockService.destructAggregateKey(aggregatedKey)
+                    : {};
+                return {
+                    ...item,
+                    ...keys,
+                };
+            }),
+        });
+        return this.shipInventoryOrderService
+            .selectQueryBuilder('orders')
+            .where('orders.id = :id', { id })
+            .getRawOne();
+    }
+    async ship(items) {
+        await this.shipInventoryOrderService.ship(items);
+        return true;
+    }
+    async cancelShip(items) {
+        return this.shipInventoryOrderService.cancelShip(items);
+    }
+};
+__decorate([
+    Mutation(() => ShipInventoryOrderDto),
+    __param(0, Args()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [CreateShipInventoryOrderArgs]),
+    __metadata("design:returntype", Promise)
+], ShipInventoryOrderMutation.prototype, "createShipInventoryOrder", null);
+__decorate([
+    Mutation(() => ShipInventoryOrderDto),
+    __param(0, Args()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [UpdateShipInventoryOrderArgs]),
+    __metadata("design:returntype", Promise)
+], ShipInventoryOrderMutation.prototype, "updateShipInventoryOrder", null);
+__decorate([
+    Mutation(() => Boolean),
+    __param(0, Args('items', { type: () => [ShipOrderArgs] })),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array]),
+    __metadata("design:returntype", Promise)
+], ShipInventoryOrderMutation.prototype, "ship", null);
+__decorate([
+    Mutation(() => Boolean),
+    __param(0, Args('items', { type: () => [CancelShipOrderArgs] })),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array]),
+    __metadata("design:returntype", Promise)
+], ShipInventoryOrderMutation.prototype, "cancelShip", null);
+ShipInventoryOrderMutation = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [ShipInventoryOrderService,
+        StockService])
+], ShipInventoryOrderMutation);
+
+export { ShipInventoryOrderMutation };

package/lib/mutations/split-batch.mutation.d.ts

@@ -0,0 +1,9 @@
+import { SplitBatchOrderService, StockService } from '@rytass/wms-module-core';
+import { SplitBatchArgs } from '../inputs/split-batch.args';
+import { SplitBatchOrderDto } from '../dto/split-batch-order.dto';
+export declare class SplitBatchMutation {
+    private readonly stockService;
+    private readonly splitBatchOrderService;
+    constructor(stockService: StockService, splitBatchOrderService: SplitBatchOrderService);
+    splitBatch(args: SplitBatchArgs): Promise<SplitBatchOrderDto>;
+}

package/lib/mutations/split-batch.mutation.js

@@ -0,0 +1,38 @@
+import { __decorate, __param, __metadata } from 'tslib';
+import { Injectable } from '@nestjs/common';
+import { Mutation, Args, Resolver } from '@nestjs/graphql';
+import { StockService, SplitBatchOrderService } from '@rytass/wms-module-core';
+import { SplitBatchArgs } from '../inputs/split-batch.args.js';
+import { SplitBatchOrderDto } from '../dto/split-batch-order.dto.js';
+
+let SplitBatchMutation = class SplitBatchMutation {
+    stockService;
+    splitBatchOrderService;
+    constructor(stockService, splitBatchOrderService) {
+        this.stockService = stockService;
+        this.splitBatchOrderService = splitBatchOrderService;
+    }
+    async splitBatch(args) {
+        const { batchId, locationId, loaderId } = this.stockService.destructAggregateKey(args.aggregatedKey);
+        return this.splitBatchOrderService.split({
+            batchId,
+            unitId: args.unitId,
+            items: args.items.map((item) => ({ ...item, locationId, loaderId })),
+        });
+    }
+};
+__decorate([
+    Mutation(() => SplitBatchOrderDto),
+    __param(0, Args()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [SplitBatchArgs]),
+    __metadata("design:returntype", Promise)
+], SplitBatchMutation.prototype, "splitBatch", null);
+SplitBatchMutation = __decorate([
+    Injectable(),
+    Resolver(),
+    __metadata("design:paramtypes", [StockService,
+        SplitBatchOrderService])
+], SplitBatchMutation);
+
+export { SplitBatchMutation };

package/lib/mutations/transfer-customer-order.mutation.d.ts

@@ -0,0 +1,12 @@
+import { StockService, TransferCustomerOrderService } from '@rytass/wms-module-core';
+import { TransferCustomerOrderDto } from '../dto/transfer-customer-order.dto';
+import { CreateTransferCustomerOrderArgs, UpdateTransferCustomerOrderArgs } from '../inputs/create-transfer-customer-order.args';
+import { ReturnTransferCustomerOrderArgs } from '../inputs/return-transfer-customer-order.args';
+export declare class TransferCustomerOrderMutation {
+    private readonly transferCustomerOrderService;
+    private readonly stockService;
+    constructor(transferCustomerOrderService: TransferCustomerOrderService, stockService: StockService);
+    createTransferCustomerOrder(args: CreateTransferCustomerOrderArgs): Promise<TransferCustomerOrderDto>;
+    updateTransferCustomerOrder(args: UpdateTransferCustomerOrderArgs): Promise<TransferCustomerOrderDto>;
+    returnTransferCustomerOrder(args: ReturnTransferCustomerOrderArgs[]): Promise<boolean>;
+}

package/lib/mutations/transfer-customer-order.mutation.js

@@ -0,0 +1,81 @@
+import { __decorate, __param, __metadata } from 'tslib';
+import { Injectable } from '@nestjs/common';
+import { Mutation, Args } from '@nestjs/graphql';
+import { TransferCustomerOrderService, StockService } from '@rytass/wms-module-core';
+import { TransferCustomerOrderDto } from '../dto/transfer-customer-order.dto.js';
+import { CreateTransferCustomerOrderArgs, UpdateTransferCustomerOrderArgs } from '../inputs/create-transfer-customer-order.args.js';
+import { ReturnTransferCustomerOrderArgs } from '../inputs/return-transfer-customer-order.args.js';
+
+let TransferCustomerOrderMutation = class TransferCustomerOrderMutation {
+    transferCustomerOrderService;
+    stockService;
+    constructor(transferCustomerOrderService, stockService) {
+        this.transferCustomerOrderService = transferCustomerOrderService;
+        this.stockService = stockService;
+    }
+    async createTransferCustomerOrder(args) {
+        return this.transferCustomerOrderService.createTransferCustomerOrder({
+            ...args,
+            items: args.items.map(({ aggregatedKey, ...item }) => {
+                const keys = this.stockService.destructAggregateKey(aggregatedKey);
+                return {
+                    ...item,
+                    ...keys,
+                };
+            }),
+        });
+    }
+    async updateTransferCustomerOrder(args) {
+        return this.transferCustomerOrderService.updateTransferCustomerOrder({
+            ...args,
+            items: args?.items?.map(({ aggregatedKey, ...item }) => {
+                const keys = aggregatedKey
+                    ? this.stockService.destructAggregateKey(aggregatedKey)
+                    : {};
+                return {
+                    ...item,
+                    ...keys,
+                };
+            }),
+        });
+    }
+    async returnTransferCustomerOrder(args) {
+        return this.transferCustomerOrderService
+            .returnTransferCustomerOrder(args.map(({ aggregatedKey, ...item }) => {
+            const keys = this.stockService.destructAggregateKey(aggregatedKey);
+            return {
+                ...item,
+                ...keys,
+            };
+        }))
+            .then(() => true);
+    }
+};
+__decorate([
+    Mutation(() => TransferCustomerOrderDto),
+    __param(0, Args()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [CreateTransferCustomerOrderArgs]),
+    __metadata("design:returntype", Promise)
+], TransferCustomerOrderMutation.prototype, "createTransferCustomerOrder", null);
+__decorate([
+    Mutation(() => TransferCustomerOrderDto),
+    __param(0, Args()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [UpdateTransferCustomerOrderArgs]),
+    __metadata("design:returntype", Promise)
+], TransferCustomerOrderMutation.prototype, "updateTransferCustomerOrder", null);
+__decorate([
+    Mutation(() => Boolean),
+    __param(0, Args('items', { type: () => [ReturnTransferCustomerOrderArgs] })),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array]),
+    __metadata("design:returntype", Promise)
+], TransferCustomerOrderMutation.prototype, "returnTransferCustomerOrder", null);
+TransferCustomerOrderMutation = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [TransferCustomerOrderService,
+        StockService])
+], TransferCustomerOrderMutation);
+
+export { TransferCustomerOrderMutation };

package/lib/mutations/transfer-order.mutation.d.ts

@@ -0,0 +1,14 @@
+import { StockService, TransferOrderService } from '@rytass/wms-module-core';
+import { TransferOrderDto } from '../dto/transfer-order.dto';
+import { CreateTransferOrderArgs, UpdateTransferOrderArgs } from '../inputs/create-transfer-order.args';
+import { TransferOrderArgs } from '../inputs/transfer-order.args';
+import { CancelTransferOrderArgs } from '../inputs/cancel-transfer-order.args';
+export declare class TransferOrderMutation {
+    private readonly transferOrderService;
+    private readonly stockService;
+    constructor(transferOrderService: TransferOrderService, stockService: StockService);
+    createTransferOrder(args: CreateTransferOrderArgs): Promise<TransferOrderDto>;
+    updateTransferOrder(args: UpdateTransferOrderArgs): Promise<TransferOrderDto>;
+    transfer(args: TransferOrderArgs[]): Promise<boolean>;
+    cancelTransfer(args: CancelTransferOrderArgs[]): Promise<boolean>;
+}

package/lib/mutations/transfer-order.mutation.js

@@ -0,0 +1,84 @@
+import { __decorate, __param, __metadata } from 'tslib';
+import { Injectable } from '@nestjs/common';
+import { Mutation, Args } from '@nestjs/graphql';
+import { TransferOrderService, StockService } from '@rytass/wms-module-core';
+import { TransferOrderDto } from '../dto/transfer-order.dto.js';
+import { CreateTransferOrderArgs, UpdateTransferOrderArgs } from '../inputs/create-transfer-order.args.js';
+import { TransferOrderArgs } from '../inputs/transfer-order.args.js';
+import { CancelTransferOrderArgs } from '../inputs/cancel-transfer-order.args.js';
+
+let TransferOrderMutation = class TransferOrderMutation {
+    transferOrderService;
+    stockService;
+    constructor(transferOrderService, stockService) {
+        this.transferOrderService = transferOrderService;
+        this.stockService = stockService;
+    }
+    async createTransferOrder(args) {
+        return this.transferOrderService.createTransferOrder({
+            ...args,
+            items: args.items.map(({ aggregatedKey, ...item }) => {
+                const keys = this.stockService.destructAggregateKey(aggregatedKey);
+                return {
+                    ...item,
+                    ...keys,
+                };
+            }),
+        });
+    }
+    async updateTransferOrder(args) {
+        return this.transferOrderService.updateTransferOrder({
+            ...args,
+            items: args?.items?.map(({ aggregatedKey, ...item }) => {
+                const keys = aggregatedKey
+                    ? this.stockService.destructAggregateKey(aggregatedKey)
+                    : {};
+                return {
+                    ...item,
+                    ...keys,
+                };
+            }),
+        });
+    }
+    async transfer(args) {
+        return this.transferOrderService.transfer(args);
+    }
+    async cancelTransfer(args) {
+        return this.transferOrderService.cancelTransfer(args);
+    }
+};
+__decorate([
+    Mutation(() => TransferOrderDto),
+    __param(0, Args()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [CreateTransferOrderArgs]),
+    __metadata("design:returntype", Promise)
+], TransferOrderMutation.prototype, "createTransferOrder", null);
+__decorate([
+    Mutation(() => TransferOrderDto),
+    __param(0, Args()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [UpdateTransferOrderArgs]),
+    __metadata("design:returntype", Promise)
+], TransferOrderMutation.prototype, "updateTransferOrder", null);
+__decorate([
+    Mutation(() => Boolean),
+    __param(0, Args('items', { type: () => [TransferOrderArgs] })),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array]),
+    __metadata("design:returntype", Promise)
+], TransferOrderMutation.prototype, "transfer", null);
+__decorate([
+    Mutation(() => Boolean),
+    __param(0, Args('items', { type: () => [CancelTransferOrderArgs] })),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array]),
+    __metadata("design:returntype", Promise)
+], TransferOrderMutation.prototype, "cancelTransfer", null);
+TransferOrderMutation = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [TransferOrderService,
+        StockService])
+], TransferOrderMutation);
+
+export { TransferOrderMutation };

package/lib/mutations/transfer-vendor-order.mutation.d.ts

@@ -0,0 +1,12 @@
+import { StockService, TransferVendorOrderService } from '@rytass/wms-module-core';
+import { TransferVendorOrderDto } from '../dto/transfer-vendor-order.dto';
+import { CreateTransferVendorOrderArgs, UpdateTransferVendorOrderArgs } from '../inputs/create-transfer-vendor-order.args';
+import { ReturnTransferVendorOrderArgs } from '../inputs/return-transfer-vendor-order.args';
+export declare class TransferVendorOrderMutation {
+    private readonly transferVendorOrderService;
+    private readonly stockService;
+    constructor(transferVendorOrderService: TransferVendorOrderService, stockService: StockService);
+    createTransferVendorOrder(args: CreateTransferVendorOrderArgs): Promise<TransferVendorOrderDto>;
+    updateTransferVendorOrder(args: UpdateTransferVendorOrderArgs): Promise<TransferVendorOrderDto>;
+    returnTransferVendorOrder(args: ReturnTransferVendorOrderArgs[]): Promise<boolean>;
+}

package/lib/mutations/transfer-vendor-order.mutation.js

@@ -0,0 +1,81 @@
+import { __decorate, __param, __metadata } from 'tslib';
+import { Injectable } from '@nestjs/common';
+import { Mutation, Args } from '@nestjs/graphql';
+import { TransferVendorOrderService, StockService } from '@rytass/wms-module-core';
+import { TransferVendorOrderDto } from '../dto/transfer-vendor-order.dto.js';
+import { CreateTransferVendorOrderArgs, UpdateTransferVendorOrderArgs } from '../inputs/create-transfer-vendor-order.args.js';
+import { ReturnTransferVendorOrderArgs } from '../inputs/return-transfer-vendor-order.args.js';
+
+let TransferVendorOrderMutation = class TransferVendorOrderMutation {
+    transferVendorOrderService;
+    stockService;
+    constructor(transferVendorOrderService, stockService) {
+        this.transferVendorOrderService = transferVendorOrderService;
+        this.stockService = stockService;
+    }
+    async createTransferVendorOrder(args) {
+        return this.transferVendorOrderService.createTransferVendorOrder({
+            ...args,
+            items: args.items.map(({ aggregatedKey, ...item }) => {
+                const keys = this.stockService.destructAggregateKey(aggregatedKey);
+                return {
+                    ...item,
+                    ...keys,
+                };
+            }),
+        });
+    }
+    async updateTransferVendorOrder(args) {
+        return this.transferVendorOrderService.updateTransferVendorOrder({
+            ...args,
+            items: args?.items?.map(({ aggregatedKey, ...item }) => {
+                const keys = aggregatedKey
+                    ? this.stockService.destructAggregateKey(aggregatedKey)
+                    : {};
+                return {
+                    ...item,
+                    ...keys,
+                };
+            }),
+        });
+    }
+    async returnTransferVendorOrder(args) {
+        return this.transferVendorOrderService
+            .returnTransferVendorOrder(args.map(({ aggregatedKey, ...item }) => {
+            const keys = this.stockService.destructAggregateKey(aggregatedKey);
+            return {
+                ...item,
+                ...keys,
+            };
+        }))
+            .then(() => true);
+    }
+};
+__decorate([
+    Mutation(() => TransferVendorOrderDto),
+    __param(0, Args()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [CreateTransferVendorOrderArgs]),
+    __metadata("design:returntype", Promise)
+], TransferVendorOrderMutation.prototype, "createTransferVendorOrder", null);
+__decorate([
+    Mutation(() => TransferVendorOrderDto),
+    __param(0, Args()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [UpdateTransferVendorOrderArgs]),
+    __metadata("design:returntype", Promise)
+], TransferVendorOrderMutation.prototype, "updateTransferVendorOrder", null);
+__decorate([
+    Mutation(() => Boolean),
+    __param(0, Args('items', { type: () => [ReturnTransferVendorOrderArgs] })),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array]),
+    __metadata("design:returntype", Promise)
+], TransferVendorOrderMutation.prototype, "returnTransferVendorOrder", null);
+TransferVendorOrderMutation = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [TransferVendorOrderService,
+        StockService])
+], TransferVendorOrderMutation);
+
+export { TransferVendorOrderMutation };

package/lib/mutations/warehouse-map.mutation.d.ts

@@ -0,0 +1,10 @@
+import { WarehouseMapService as WarehouseMapBaseService } from '@rytass/wms-base-nestjs-module';
+import { MapDataDto } from '../dto/warehouse-map.dto';
+import { UpdateWarehouseMapArgs } from '../inputs/update-warehouse-map.args';
+import { WarehouseMapDataService } from '@rytass/wms-module-core';
+export declare class WarehouseMapMutation {
+    private readonly warehouseMapBaseService;
+    private readonly warehouseMapService;
+    constructor(warehouseMapBaseService: WarehouseMapBaseService, warehouseMapService: WarehouseMapDataService);
+    updateWarehouseMap(args: UpdateWarehouseMapArgs): Promise<MapDataDto>;
+}

package/lib/mutations/warehouse-map.mutation.js

@@ -0,0 +1,54 @@
+import { __decorate, __param, __metadata } from 'tslib';
+import { Injectable } from '@nestjs/common';
+import { WarehouseMapService } from '@rytass/wms-base-nestjs-module';
+import { MapDataDto } from '../dto/warehouse-map.dto.js';
+import { Mutation, Args } from '@nestjs/graphql';
+import { UpdateWarehouseMapArgs } from '../inputs/update-warehouse-map.args.js';
+import { WarehouseMapDataService } from '@rytass/wms-module-core';
+import { In } from 'typeorm';
+
+let WarehouseMapMutation = class WarehouseMapMutation {
+    warehouseMapBaseService;
+    warehouseMapService;
+    constructor(warehouseMapBaseService, warehouseMapService) {
+        this.warehouseMapBaseService = warehouseMapBaseService;
+        this.warehouseMapService = warehouseMapService;
+    }
+    async updateWarehouseMap(args) {
+        const { mapData } = await this.warehouseMapBaseService.updateMap(args.locationKey, args.backgrounds, args.ranges);
+        if (mapData.ranges) {
+            const rangeIds = mapData.ranges.map(({ id }) => id);
+            const existedIds = await this.warehouseMapService.warehouseMapDataRepository
+                .findBy({
+                id: In(rangeIds),
+            })
+                .then((entities) => entities.map(({ id }) => id));
+            const notExistedIds = rangeIds.filter((id) => !existedIds.includes(id));
+            if (notExistedIds.length) {
+                await this.warehouseMapService.warehouseMapDataRepository.save(notExistedIds.map((id) => this.warehouseMapService.warehouseMapDataRepository.create({
+                    id,
+                    mapData: {
+                        id,
+                        backgrounds: [],
+                        ranges: [],
+                    },
+                })));
+            }
+        }
+        return mapData;
+    }
+};
+__decorate([
+    Mutation(() => MapDataDto),
+    __param(0, Args()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [UpdateWarehouseMapArgs]),
+    __metadata("design:returntype", Promise)
+], WarehouseMapMutation.prototype, "updateWarehouseMap", null);
+WarehouseMapMutation = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [WarehouseMapService,
+        WarehouseMapDataService])
+], WarehouseMapMutation);
+
+export { WarehouseMapMutation };

package/lib/queries/allocate-inventory-order.query.d.ts

@@ -0,0 +1,8 @@
+import { AllocateInventoryOrders } from '../dto/allocate-inventory-order.dto';
+import { AllocateInventoryOrderService } from '@rytass/wms-module-core';
+import { FindAllocateInventoryOrderArgs } from '../inputs/find-allocate-inventory-order.args';
+export declare class AllocateInventoryOrderQuery {
+    private readonly allocateInventoryOrderService;
+    constructor(allocateInventoryOrderService: AllocateInventoryOrderService);
+    allocateInventoryOrders(args: FindAllocateInventoryOrderArgs): Promise<AllocateInventoryOrders>;
+}

package/lib/queries/allocate-inventory-order.query.js

@@ -0,0 +1,30 @@
+import { __decorate, __param, __metadata } from 'tslib';
+import { Injectable } from '@nestjs/common';
+import { Query, Args } from '@nestjs/graphql';
+import { AllocateInventoryOrders } from '../dto/allocate-inventory-order.dto.js';
+import { AllocateInventoryOrderService } from '@rytass/wms-module-core';
+import { FindAllocateInventoryOrderArgs } from '../inputs/find-allocate-inventory-order.args.js';
+
+let AllocateInventoryOrderQuery = class AllocateInventoryOrderQuery {
+    allocateInventoryOrderService;
+    constructor(allocateInventoryOrderService) {
+        this.allocateInventoryOrderService = allocateInventoryOrderService;
+    }
+    async allocateInventoryOrders(args) {
+        const [items, total] = await this.allocateInventoryOrderService.findMany(args);
+        return { items, total };
+    }
+};
+__decorate([
+    Query(() => AllocateInventoryOrders),
+    __param(0, Args()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [FindAllocateInventoryOrderArgs]),
+    __metadata("design:returntype", Promise)
+], AllocateInventoryOrderQuery.prototype, "allocateInventoryOrders", null);
+AllocateInventoryOrderQuery = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [AllocateInventoryOrderService])
+], AllocateInventoryOrderQuery);
+
+export { AllocateInventoryOrderQuery };

package/lib/queries/batch.query.d.ts

@@ -0,0 +1,8 @@
+import { Batches } from '../dto/batch.dto';
+import { BatchService } from '@rytass/wms-module-core';
+import { FindBatchArgs } from '../inputs/find-batch.args';
+export declare class BatchQuery {
+    private readonly batchService;
+    constructor(batchService: BatchService);
+    batches(args: FindBatchArgs): Promise<Batches>;
+}

package/lib/queries/batch.query.js

@@ -0,0 +1,33 @@
+import { __decorate, __param, __metadata } from 'tslib';
+import { Injectable } from '@nestjs/common';
+import { Query, Args } from '@nestjs/graphql';
+import { Batches } from '../dto/batch.dto.js';
+import { BatchService } from '@rytass/wms-module-core';
+import { FindBatchArgs } from '../inputs/find-batch.args.js';
+
+let BatchQuery = class BatchQuery {
+    batchService;
+    constructor(batchService) {
+        this.batchService = batchService;
+    }
+    async batches(args) {
+        const [items, total] = await this.batchService.findMany({
+            ...args,
+            wildcard: args.key ? { key: 'key', value: args.key } : undefined,
+        });
+        return { items, total };
+    }
+};
+__decorate([
+    Query(() => Batches),
+    __param(0, Args()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [FindBatchArgs]),
+    __metadata("design:returntype", Promise)
+], BatchQuery.prototype, "batches", null);
+BatchQuery = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [BatchService])
+], BatchQuery);
+
+export { BatchQuery };

package/lib/queries/hold-inventory-order.query.d.ts

@@ -0,0 +1,8 @@
+import { HoldInventoryOrderService } from '@rytass/wms-module-core';
+import { HoldInventoryOrders } from '../dto/hold-inventory-order.dto';
+import { FindHoldInventoryOrderArgs } from '../inputs/find-hold-inventory-order.args';
+export declare class HoldInventoryOrderQuery {
+    private readonly holdInventoryOrderService;
+    constructor(holdInventoryOrderService: HoldInventoryOrderService);
+    holdInventoryOrders(args: FindHoldInventoryOrderArgs): Promise<HoldInventoryOrders>;
+}

package/lib/queries/hold-inventory-order.query.js

@@ -0,0 +1,30 @@
+import { __decorate, __param, __metadata } from 'tslib';
+import { Injectable } from '@nestjs/common';
+import { Query, Args } from '@nestjs/graphql';
+import { HoldInventoryOrderService } from '@rytass/wms-module-core';
+import { HoldInventoryOrders } from '../dto/hold-inventory-order.dto.js';
+import { FindHoldInventoryOrderArgs } from '../inputs/find-hold-inventory-order.args.js';
+
+let HoldInventoryOrderQuery = class HoldInventoryOrderQuery {
+    holdInventoryOrderService;
+    constructor(holdInventoryOrderService) {
+        this.holdInventoryOrderService = holdInventoryOrderService;
+    }
+    async holdInventoryOrders(args) {
+        const [items, total] = await this.holdInventoryOrderService.findMany(args);
+        return { items, total };
+    }
+};
+__decorate([
+    Query(() => HoldInventoryOrders),
+    __param(0, Args()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [FindHoldInventoryOrderArgs]),
+    __metadata("design:returntype", Promise)
+], HoldInventoryOrderQuery.prototype, "holdInventoryOrders", null);
+HoldInventoryOrderQuery = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [HoldInventoryOrderService])
+], HoldInventoryOrderQuery);
+
+export { HoldInventoryOrderQuery };

package/lib/queries/loader.query.d.ts

@@ -0,0 +1,17 @@
+import { LoaderService, StockService, TransferOrderService } from '@rytass/wms-module-core';
+import { LoaderDto, Loaders, LoaderTypeDto, LoaderTypes } from '../dto';
+import { FindLoaderArgs } from '../inputs/find-loader.args';
+import { FindLoaderTypeArgs } from '../inputs/find-loader-type.args';
+import { LoaderUnit, LoaderUnitDto } from '../dto/loader-unit.dto';
+export declare class LoaderQuery {
+    private readonly loaderService;
+    private readonly stockService;
+    private readonly transferOrderService;
+    constructor(loaderService: LoaderService, stockService: StockService, transferOrderService: TransferOrderService);
+    loader(id: string): Promise<LoaderDto>;
+    loaders(args: FindLoaderArgs): Promise<Loaders>;
+    loaderType(id: string): Promise<LoaderTypeDto>;
+    loaderTypes(args: FindLoaderTypeArgs): Promise<LoaderTypes>;
+    loaderUnits(type: LoaderUnit): Promise<LoaderUnitDto[]>;
+    availableLoaders(locationId?: string): Promise<LoaderDto[]>;
+}