@rytass/wms-module-graphql 0.11.1 → 0.12.0

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

@@ -1,123 +0,0 @@
-import { __decorate, __param, __metadata } from 'tslib';
-import { Injectable } from '@nestjs/common';
-import { ShipInventoryOrderService, StockService } from '@rytass/wms-module-core';
-import '../dto/loader-type.dto.mjs';
-import '../dto/loader.dto.mjs';
-import '../dto/material.dto.mjs';
-import '../dto/material-unit.dto.mjs';
-import '../dto/stock.dto.mjs';
-import '../dto/sale-order.dto.mjs';
-import '../dto/receive-inventory-order.dto.mjs';
-import '../dto/receive-inventory-order-item.dto.mjs';
-import { ShipInventoryOrderDto } from '../dto/ship-inventory-order.dto.mjs';
-import '../dto/ship-inventory-order-item.dto.mjs';
-import '../dto/hold-inventory-order.dto.mjs';
-import '../dto/hold-inventory-order-item.dto.mjs';
-import '../dto/allocate-inventory-order.dto.mjs';
-import '../dto/allocate-inventory-order-item.dto.mjs';
-import '../dto/transfer-order.dto.mjs';
-import '../dto/transfer-order-item.dto.mjs';
-import '../dto/transfer-customer-order.dto.mjs';
-import '../dto/transfer-customer-order-item.dto.mjs';
-import '../dto/transfer-vendor-order.dto.mjs';
-import '../dto/transfer-vendor-order-item.dto.mjs';
-import '../dto/scrape-order.dto.mjs';
-import '../dto/scrape-order-item.dto.mjs';
-import '../dto/quality-inspection-order.dto.mjs';
-import '../dto/quality-inspection-order-item.dto.mjs';
-import '../dto/inventory-count-order.dto.mjs';
-import '../dto/consumption-order.dto.mjs';
-import '../dto/consumption-order-item.dto.mjs';
-import '../dto/order-reference.dto.mjs';
-import { Mutation, Args } from '@nestjs/graphql';
-import { CreateShipInventoryOrderArgs, UpdateShipInventoryOrderArgs } from '../inputs/create-ship-inventory-order.args.mjs';
-import { ShipOrderArgs } from '../inputs/ship-order.args.mjs';
-import { CancelShipOrderArgs } from '../inputs/cancel-ship-order.args.mjs';
-import '../auth/wms-auth.guard.mjs';
-import { WmsOperation } from '../auth/wms-operation.decorator.mjs';
-import { WmsMutationEvent } from '../events/wms-mutation-event.decorator.mjs';
-import '../events/wms-mutation.interceptor.mjs';
-
-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),
-    WmsOperation({ resource: 'ship-inventory-order', action: 'create' }),
-    WmsMutationEvent({ event: 'ship-inventory-order.created' }),
-    __param(0, Args()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [CreateShipInventoryOrderArgs]),
-    __metadata("design:returntype", Promise)
-], ShipInventoryOrderMutation.prototype, "createShipInventoryOrder", null);
-__decorate([
-    Mutation(() => ShipInventoryOrderDto),
-    WmsOperation({ resource: 'ship-inventory-order', action: 'update' }),
-    WmsMutationEvent({ event: 'ship-inventory-order.updated' }),
-    __param(0, Args()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [UpdateShipInventoryOrderArgs]),
-    __metadata("design:returntype", Promise)
-], ShipInventoryOrderMutation.prototype, "updateShipInventoryOrder", null);
-__decorate([
-    Mutation(() => Boolean),
-    WmsOperation({ resource: 'ship-inventory-order', action: 'ship' }),
-    WmsMutationEvent({ event: 'ship-inventory-order.shipped' }),
-    __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),
-    WmsOperation({ resource: 'ship-inventory-order', action: 'cancel' }),
-    WmsMutationEvent({ event: 'ship-inventory-order.ship-cancelled' }),
-    __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.mjs

@@ -1,44 +0,0 @@
-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.mjs';
-import { SplitBatchOrderDto } from '../dto/split-batch-order.dto.mjs';
-import '../auth/wms-auth.guard.mjs';
-import { WmsOperation } from '../auth/wms-operation.decorator.mjs';
-import { WmsMutationEvent } from '../events/wms-mutation-event.decorator.mjs';
-import '../events/wms-mutation.interceptor.mjs';
-
-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),
-    WmsOperation({ resource: 'batch', action: 'split' }),
-    WmsMutationEvent({ event: 'batch.splitted' }),
-    __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.mjs

@@ -1,91 +0,0 @@
-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.mjs';
-import { CreateTransferCustomerOrderArgs, UpdateTransferCustomerOrderArgs } from '../inputs/create-transfer-customer-order.args.mjs';
-import { ReturnTransferCustomerOrderArgs } from '../inputs/return-transfer-customer-order.args.mjs';
-import '../auth/wms-auth.guard.mjs';
-import { WmsOperation } from '../auth/wms-operation.decorator.mjs';
-import { WmsMutationEvent } from '../events/wms-mutation-event.decorator.mjs';
-import '../events/wms-mutation.interceptor.mjs';
-
-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),
-    WmsOperation({ resource: 'transfer-customer-order', action: 'create' }),
-    WmsMutationEvent({ event: 'transfer-customer-order.created' }),
-    __param(0, Args()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [CreateTransferCustomerOrderArgs]),
-    __metadata("design:returntype", Promise)
-], TransferCustomerOrderMutation.prototype, "createTransferCustomerOrder", null);
-__decorate([
-    Mutation(() => TransferCustomerOrderDto),
-    WmsOperation({ resource: 'transfer-customer-order', action: 'update' }),
-    WmsMutationEvent({ event: 'transfer-customer-order.updated' }),
-    __param(0, Args()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [UpdateTransferCustomerOrderArgs]),
-    __metadata("design:returntype", Promise)
-], TransferCustomerOrderMutation.prototype, "updateTransferCustomerOrder", null);
-__decorate([
-    Mutation(() => Boolean),
-    WmsOperation({ resource: 'transfer-customer-order', action: 'return' }),
-    WmsMutationEvent({ event: 'transfer-customer-order.returned' }),
-    __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.mjs

@@ -1,96 +0,0 @@
-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.mjs';
-import { CreateTransferOrderArgs, UpdateTransferOrderArgs } from '../inputs/create-transfer-order.args.mjs';
-import { TransferOrderArgs } from '../inputs/transfer-order.args.mjs';
-import { CancelTransferOrderArgs } from '../inputs/cancel-transfer-order.args.mjs';
-import '../auth/wms-auth.guard.mjs';
-import { WmsOperation } from '../auth/wms-operation.decorator.mjs';
-import { WmsMutationEvent } from '../events/wms-mutation-event.decorator.mjs';
-import '../events/wms-mutation.interceptor.mjs';
-
-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),
-    WmsOperation({ resource: 'transfer-order', action: 'create' }),
-    WmsMutationEvent({ event: 'transfer-order.created' }),
-    __param(0, Args()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [CreateTransferOrderArgs]),
-    __metadata("design:returntype", Promise)
-], TransferOrderMutation.prototype, "createTransferOrder", null);
-__decorate([
-    Mutation(() => TransferOrderDto),
-    WmsOperation({ resource: 'transfer-order', action: 'update' }),
-    WmsMutationEvent({ event: 'transfer-order.updated' }),
-    __param(0, Args()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [UpdateTransferOrderArgs]),
-    __metadata("design:returntype", Promise)
-], TransferOrderMutation.prototype, "updateTransferOrder", null);
-__decorate([
-    Mutation(() => Boolean),
-    WmsOperation({ resource: 'transfer-order', action: 'transfer' }),
-    WmsMutationEvent({ event: 'transfer-order.transferred' }),
-    __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),
-    WmsOperation({ resource: 'transfer-order', action: 'cancel' }),
-    WmsMutationEvent({ event: 'transfer-order.transfer-cancelled' }),
-    __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.mjs

@@ -1,91 +0,0 @@
-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.mjs';
-import { CreateTransferVendorOrderArgs, UpdateTransferVendorOrderArgs } from '../inputs/create-transfer-vendor-order.args.mjs';
-import { ReturnTransferVendorOrderArgs } from '../inputs/return-transfer-vendor-order.args.mjs';
-import '../auth/wms-auth.guard.mjs';
-import { WmsOperation } from '../auth/wms-operation.decorator.mjs';
-import { WmsMutationEvent } from '../events/wms-mutation-event.decorator.mjs';
-import '../events/wms-mutation.interceptor.mjs';
-
-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),
-    WmsOperation({ resource: 'transfer-vendor-order', action: 'create' }),
-    WmsMutationEvent({ event: 'transfer-vendor-order.created' }),
-    __param(0, Args()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [CreateTransferVendorOrderArgs]),
-    __metadata("design:returntype", Promise)
-], TransferVendorOrderMutation.prototype, "createTransferVendorOrder", null);
-__decorate([
-    Mutation(() => TransferVendorOrderDto),
-    WmsOperation({ resource: 'transfer-vendor-order', action: 'update' }),
-    WmsMutationEvent({ event: 'transfer-vendor-order.updated' }),
-    __param(0, Args()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [UpdateTransferVendorOrderArgs]),
-    __metadata("design:returntype", Promise)
-], TransferVendorOrderMutation.prototype, "updateTransferVendorOrder", null);
-__decorate([
-    Mutation(() => Boolean),
-    WmsOperation({ resource: 'transfer-vendor-order', action: 'return' }),
-    WmsMutationEvent({ event: 'transfer-vendor-order.returned' }),
-    __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.mjs

@@ -1,60 +0,0 @@
-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.mjs';
-import { Mutation, Args } from '@nestjs/graphql';
-import { UpdateWarehouseMapArgs } from '../inputs/update-warehouse-map.args.mjs';
-import { WarehouseMapDataService } from '@rytass/wms-module-core';
-import { In } from 'typeorm';
-import '../auth/wms-auth.guard.mjs';
-import { WmsOperation } from '../auth/wms-operation.decorator.mjs';
-import { WmsMutationEvent } from '../events/wms-mutation-event.decorator.mjs';
-import '../events/wms-mutation.interceptor.mjs';
-
-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),
-    WmsOperation({ resource: 'warehouse-map', action: 'update' }),
-    WmsMutationEvent({ event: 'warehouse-map.updated' }),
-    __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.mjs

@@ -1,33 +0,0 @@
-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.mjs';
-import { AllocateInventoryOrderService } from '@rytass/wms-module-core';
-import { FindAllocateInventoryOrderArgs } from '../inputs/find-allocate-inventory-order.args.mjs';
-import '../auth/wms-auth.guard.mjs';
-import { WmsOperation } from '../auth/wms-operation.decorator.mjs';
-
-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),
-    WmsOperation({ resource: 'allocate-inventory-order', action: 'read' }),
-    __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.mjs

@@ -1,36 +0,0 @@
-import { __decorate, __param, __metadata } from 'tslib';
-import { Injectable } from '@nestjs/common';
-import { Query, Args } from '@nestjs/graphql';
-import { Batches } from '../dto/batch.dto.mjs';
-import { BatchService } from '@rytass/wms-module-core';
-import { FindBatchArgs } from '../inputs/find-batch.args.mjs';
-import '../auth/wms-auth.guard.mjs';
-import { WmsOperation } from '../auth/wms-operation.decorator.mjs';
-
-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),
-    WmsOperation({ resource: 'batch', action: 'read' }),
-    __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/consumption-order.query.mjs

@@ -1,45 +0,0 @@
-import { __decorate, __param, __metadata } from 'tslib';
-import { Injectable } from '@nestjs/common';
-import { Query, Args, ID, Resolver } from '@nestjs/graphql';
-import { ConsumptionOrderService } from '@rytass/wms-module-core';
-import { ConsumptionOrderDto, ConsumptionOrders } from '../dto/consumption-order.dto.mjs';
-import { FindConsumptionOrderArgs } from '../inputs/consumption-order.args.mjs';
-import '../auth/wms-auth.guard.mjs';
-import { WmsOperation } from '../auth/wms-operation.decorator.mjs';
-
-let ConsumptionOrderQuery = class ConsumptionOrderQuery {
-    consumptionOrderService;
-    constructor(consumptionOrderService) {
-        this.consumptionOrderService = consumptionOrderService;
-    }
-    consumptionOrder(id) {
-        return this.consumptionOrderService.findOne(id);
-    }
-    async consumptionOrders(args) {
-        const [items, total] = await this.consumptionOrderService.findMany(args);
-        return { items, total };
-    }
-};
-__decorate([
-    Query(() => ConsumptionOrderDto),
-    WmsOperation({ resource: 'consumption-order', action: 'read' }),
-    __param(0, Args('id', { type: () => ID })),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String]),
-    __metadata("design:returntype", Promise)
-], ConsumptionOrderQuery.prototype, "consumptionOrder", null);
-__decorate([
-    Query(() => ConsumptionOrders),
-    WmsOperation({ resource: 'consumption-order', action: 'read' }),
-    __param(0, Args()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [FindConsumptionOrderArgs]),
-    __metadata("design:returntype", Promise)
-], ConsumptionOrderQuery.prototype, "consumptionOrders", null);
-ConsumptionOrderQuery = __decorate([
-    Injectable(),
-    Resolver(),
-    __metadata("design:paramtypes", [ConsumptionOrderService])
-], ConsumptionOrderQuery);
-
-export { ConsumptionOrderQuery };

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

@@ -1,33 +0,0 @@
-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.mjs';
-import { FindHoldInventoryOrderArgs } from '../inputs/find-hold-inventory-order.args.mjs';
-import '../auth/wms-auth.guard.mjs';
-import { WmsOperation } from '../auth/wms-operation.decorator.mjs';
-
-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),
-    WmsOperation({ resource: 'hold-inventory-order', action: 'read' }),
-    __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 };