@rytass/wms-module-graphql 0.1.0

package/lib/queries/loader.query.js

@@ -0,0 +1,157 @@
+import { __decorate, __param, __metadata } from 'tslib';
+import { Injectable } from '@nestjs/common';
+import { Query, Args, ID } from '@nestjs/graphql';
+import { LoaderService, StockService, TransferOrderService, TransferOrderItemEntityClass, TransferOrderChangeEntityClass } from '@rytass/wms-module-core';
+import { LoaderTypeDto, LoaderTypes } from '../dto/loader-type.dto.js';
+import { LoaderDto, Loaders } from '../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 '../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 { FindLoaderArgs } from '../inputs/find-loader.args.js';
+import { FindLoaderTypeArgs } from '../inputs/find-loader-type.args.js';
+import { LoaderUnitDto, LoaderUnit } from '../dto/loader-unit.dto.js';
+
+let LoaderQuery = class LoaderQuery {
+    loaderService;
+    stockService;
+    transferOrderService;
+    constructor(loaderService, stockService, transferOrderService) {
+        this.loaderService = loaderService;
+        this.stockService = stockService;
+        this.transferOrderService = transferOrderService;
+    }
+    loader(id) {
+        return this.loaderService.loaderRepository.findOneByOrFail({ id });
+    }
+    async loaders(args) {
+        const [items, total] = await this.loaderService.findManyLoaders({
+            ...args,
+            wildcard: args.key ? { key: 'serialId', value: args.key } : undefined,
+        });
+        return { items, total };
+    }
+    async loaderType(id) {
+        return this.loaderService.loaderTypeRepository.findOneByOrFail({ id });
+    }
+    async loaderTypes(args) {
+        const [items, total] = await this.loaderService.findManyLoaderTypes({
+            ...args,
+            wildcard: args.key ? { key: 'key', value: args.key } : undefined,
+        });
+        return { items, total };
+    }
+    loaderUnits(type) {
+        return this.loaderService.loaderUnitRepository.findBy({
+            type,
+        });
+    }
+    async availableLoaders(locationId) {
+        const loaders = [];
+        // every loaders from locationId +
+        // (loaders with empty stocks - loader with empty stocks but being used as targetLoader in transfer order that being booked)
+        const allLoaders = await this.loaderService.loaderRepository.findBy({
+            isActive: true,
+        });
+        if (locationId)
+            allLoaders.forEach((loader) => {
+                if (loader.locationId === locationId)
+                    loaders.push(loader);
+            });
+        const [aggregatedStocks] = await this.stockService.findAggregatedStocks({
+            aggregated: true,
+        });
+        // Collect loaderIds that currently have stock
+        const loaderIdsWithStock = new Set(aggregatedStocks.map((s) => s.loaderId).filter(Boolean));
+        // Find targetLoaderIds booked in not-yet-executed transfer order items
+        const bookedRows = await this.transferOrderService.transferOrderRepository.manager
+            .getRepository(TransferOrderItemEntityClass)
+            .createQueryBuilder('toi')
+            .select('toi."targetLoaderId"', 'targetLoaderId')
+            .where('toi."targetLoaderId" IS NOT NULL')
+            .andWhere('toi."removedAt" IS NULL')
+            .leftJoin(TransferOrderChangeEntityClass, 'toc', 'toc."itemId" = toi.id')
+            .andWhere('toc.id IS NULL')
+            .distinct(true)
+            .getRawMany();
+        const bookedLoaderIdSet = new Set(bookedRows.map((r) => r.targetLoaderId));
+        // Add empty loaders (no stock) that are not booked as a pending targetLoader
+        const collectedIds = new Set(loaders.map((l) => l.id));
+        for (const loader of allLoaders) {
+            if (!loaderIdsWithStock.has(loader.id) &&
+                !bookedLoaderIdSet.has(loader.id) &&
+                !collectedIds.has(loader.id)) {
+                loaders.push(loader);
+            }
+        }
+        return loaders;
+    }
+};
+__decorate([
+    Query(() => LoaderDto),
+    __param(0, Args('id', { type: () => ID })),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], LoaderQuery.prototype, "loader", null);
+__decorate([
+    Query(() => Loaders),
+    __param(0, Args()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [FindLoaderArgs]),
+    __metadata("design:returntype", Promise)
+], LoaderQuery.prototype, "loaders", null);
+__decorate([
+    Query(() => LoaderTypeDto),
+    __param(0, Args('id', { type: () => ID })),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], LoaderQuery.prototype, "loaderType", null);
+__decorate([
+    Query(() => LoaderTypes),
+    __param(0, Args()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [FindLoaderTypeArgs]),
+    __metadata("design:returntype", Promise)
+], LoaderQuery.prototype, "loaderTypes", null);
+__decorate([
+    Query(() => [LoaderUnitDto]),
+    __param(0, Args('type', { type: () => LoaderUnit })),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], LoaderQuery.prototype, "loaderUnits", null);
+__decorate([
+    Query(() => [LoaderDto]),
+    __param(0, Args('locationId', { type: () => ID, nullable: true })),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], LoaderQuery.prototype, "availableLoaders", null);
+LoaderQuery = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [LoaderService,
+        StockService,
+        TransferOrderService])
+], LoaderQuery);
+
+export { LoaderQuery };

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

@@ -0,0 +1,9 @@
+import { LocationService } from '@rytass/wms-module-core';
+import { LocationDto, Locations } from '../dto/location.dto';
+import { FindLocationArgs } from '../inputs/find-location.args';
+export declare class LocationQuery {
+    private readonly locationService;
+    constructor(locationService: LocationService);
+    location(id: string): Promise<LocationDto>;
+    locations(args: FindLocationArgs): Promise<Locations>;
+}

package/lib/queries/location.query.js

@@ -0,0 +1,47 @@
+import { __decorate, __param, __metadata } from 'tslib';
+import { Injectable } from '@nestjs/common';
+import { Query, Args, ID } from '@nestjs/graphql';
+import { LocationService } from '@rytass/wms-module-core';
+import { LocationDto, Locations } from '../dto/location.dto.js';
+import { FindLocationArgs } from '../inputs/find-location.args.js';
+
+let LocationQuery = class LocationQuery {
+    locationService;
+    constructor(locationService) {
+        this.locationService = locationService;
+    }
+    location(id) {
+        return this.locationService.locationReposistory
+            .createQueryBuilder('location')
+            .leftJoinAndSelect('location.children', 'children')
+            .where('location.id = :id', { id })
+            .getOneOrFail();
+    }
+    async locations(args) {
+        const [items, total] = await this.locationService.findMany({
+            ...args,
+            wildcard: args.key ? { key: 'key', value: args.key } : undefined,
+        });
+        return { items, total };
+    }
+};
+__decorate([
+    Query(() => LocationDto),
+    __param(0, Args('id', { type: () => ID })),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], LocationQuery.prototype, "location", null);
+__decorate([
+    Query(() => Locations),
+    __param(0, Args()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [FindLocationArgs]),
+    __metadata("design:returntype", Promise)
+], LocationQuery.prototype, "locations", null);
+LocationQuery = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [LocationService])
+], LocationQuery);
+
+export { LocationQuery };

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

@@ -0,0 +1,9 @@
+import { MaterialDto, Materials } from '../dto';
+import { MaterialService } from '@rytass/wms-module-core';
+import { FindMaterialArgs } from '../inputs/find-material.args';
+export declare class MaterialQuery {
+    private readonly materialService;
+    constructor(materialService: MaterialService);
+    material(id?: string, key?: string): Promise<MaterialDto>;
+    materials(args: FindMaterialArgs): Promise<Materials>;
+}

package/lib/queries/material.query.js

@@ -0,0 +1,71 @@
+import { __decorate, __param, __metadata } from 'tslib';
+import { Injectable } from '@nestjs/common';
+import { Query, Args, ID } from '@nestjs/graphql';
+import '../dto/loader-type.dto.js';
+import '../dto/loader.dto.js';
+import { MaterialDto, Materials } 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 '../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 { MaterialService } from '@rytass/wms-module-core';
+import { FindMaterialArgs } from '../inputs/find-material.args.js';
+
+let MaterialQuery = class MaterialQuery {
+    materialService;
+    constructor(materialService) {
+        this.materialService = materialService;
+    }
+    material(id, key) {
+        const where = id ? { id } : key ? { key } : undefined;
+        if (!where) {
+            throw new Error('Either id or key must be provided');
+        }
+        return this.materialService.materialRepository.findOneByOrFail(where);
+    }
+    async materials(args) {
+        const [items, total] = await this.materialService.findMany({
+            ...args,
+            wildcard: args.key ? { key: 'key', value: args.key } : undefined,
+        });
+        return { items, total };
+    }
+};
+__decorate([
+    Query(() => MaterialDto),
+    __param(0, Args('id', { type: () => ID, nullable: true })),
+    __param(1, Args('key', { type: () => String, nullable: true })),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String]),
+    __metadata("design:returntype", Promise)
+], MaterialQuery.prototype, "material", null);
+__decorate([
+    Query(() => Materials),
+    __param(0, Args()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [FindMaterialArgs]),
+    __metadata("design:returntype", Promise)
+], MaterialQuery.prototype, "materials", null);
+MaterialQuery = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [MaterialService])
+], MaterialQuery);
+
+export { MaterialQuery };

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

@@ -0,0 +1,9 @@
+import { ReceiveInventoryOrderService } from '@rytass/wms-module-core';
+import { ReceiveInventoryOrderDto, ReceiveInventoryOrders } from '../dto';
+import { FindReceiveInventoryOrderArgs } from '../inputs/find-receive-inventory-order.args';
+export declare class ReceiveInventoryOrderQuery {
+    private readonly receiveInventoryOrderService;
+    constructor(receiveInventoryOrderService: ReceiveInventoryOrderService);
+    receiveInventoryOrder(id: string): Promise<ReceiveInventoryOrderDto>;
+    receiveInventoryOrders(args: FindReceiveInventoryOrderArgs): Promise<ReceiveInventoryOrders>;
+}

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

@@ -0,0 +1,69 @@
+import { __decorate, __param, __metadata } from 'tslib';
+import { Injectable } from '@nestjs/common';
+import { Query, Args, ID } from '@nestjs/graphql';
+import { ReceiveInventoryOrderService } 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 { ReceiveInventoryOrderDto, ReceiveInventoryOrders } from '../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 { FindReceiveInventoryOrderArgs } from '../inputs/find-receive-inventory-order.args.js';
+
+let ReceiveInventoryOrderQuery = class ReceiveInventoryOrderQuery {
+    receiveInventoryOrderService;
+    constructor(receiveInventoryOrderService) {
+        this.receiveInventoryOrderService = receiveInventoryOrderService;
+    }
+    async receiveInventoryOrder(id) {
+        return this.receiveInventoryOrderService
+            .selectQueryBuilder('orders')
+            .where('orders.id = :id', { id })
+            .getRawOne();
+    }
+    async receiveInventoryOrders(args) {
+        const [items, total] = await this.receiveInventoryOrderService.findMany({
+            ...args,
+            wildcard: args.key ? { key: 'key', value: args.key } : undefined,
+        });
+        return { items, total };
+    }
+};
+__decorate([
+    Query(() => ReceiveInventoryOrderDto),
+    __param(0, Args('id', { type: () => ID })),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], ReceiveInventoryOrderQuery.prototype, "receiveInventoryOrder", null);
+__decorate([
+    Query(() => ReceiveInventoryOrders),
+    __param(0, Args()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [FindReceiveInventoryOrderArgs]),
+    __metadata("design:returntype", Promise)
+], ReceiveInventoryOrderQuery.prototype, "receiveInventoryOrders", null);
+ReceiveInventoryOrderQuery = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [ReceiveInventoryOrderService])
+], ReceiveInventoryOrderQuery);
+
+export { ReceiveInventoryOrderQuery };

package/lib/queries/sale-order.query.d.ts

@@ -0,0 +1,8 @@
+import { SaleOrderService } from '@rytass/wms-module-core';
+import { FindSaleOrderArgs } from '../inputs/find-sale-order.args';
+export declare class SaleOrderQuery {
+    private readonly saleOrderService;
+    constructor(saleOrderService: SaleOrderService);
+    saleOrderDistinctIds(args?: FindSaleOrderArgs): Promise<string[]>;
+    saleOrders(id: string): Promise<string[]>;
+}

package/lib/queries/sale-order.query.js

@@ -0,0 +1,53 @@
+import { __decorate, __param, __metadata } from 'tslib';
+import { Injectable } from '@nestjs/common';
+import { Query, Args, ID } from '@nestjs/graphql';
+import { SaleOrderService } from '@rytass/wms-module-core';
+import { FindSaleOrderArgs } from '../inputs/find-sale-order.args.js';
+
+let SaleOrderQuery = class SaleOrderQuery {
+    saleOrderService;
+    constructor(saleOrderService) {
+        this.saleOrderService = saleOrderService;
+    }
+    async saleOrderDistinctIds(args) {
+        const builder = this.saleOrderService.saleOrderRepository
+            .createQueryBuilder('so')
+            .select('DISTINCT so.id', 'id');
+        if (args?.key)
+            builder.where('so.id LIKE :key', {
+                key: `%${args.key}%`,
+            });
+        if (args?.offset !== undefined && args.offset >= 0)
+            builder.skip(args.offset);
+        if (args?.limit !== undefined && args.limit > 0)
+            builder.take(args.limit);
+        const result = await builder.getRawMany();
+        return result.map(({ id }) => id);
+    }
+    async saleOrders(id) {
+        const result = await this.saleOrderService.saleOrderRepository.findBy({
+            id,
+        });
+        return result.map(({ serialId }) => serialId);
+    }
+};
+__decorate([
+    Query(() => [String]),
+    __param(0, Args()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [FindSaleOrderArgs]),
+    __metadata("design:returntype", Promise)
+], SaleOrderQuery.prototype, "saleOrderDistinctIds", null);
+__decorate([
+    Query(() => [String]),
+    __param(0, Args('id', { type: () => ID })),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], SaleOrderQuery.prototype, "saleOrders", null);
+SaleOrderQuery = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [SaleOrderService])
+], SaleOrderQuery);
+
+export { SaleOrderQuery };

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

@@ -0,0 +1,9 @@
+import { ShipInventoryOrderService } from '@rytass/wms-module-core';
+import { ShipInventoryOrderDto, ShipInventoryOrders } from '../dto';
+import { FindShipInventoryOrderArgs } from '../inputs/find-ship-inventory-order.args';
+export declare class ShipInventoryOrderQuery {
+    private readonly shipInventoryOrderService;
+    constructor(shipInventoryOrderService: ShipInventoryOrderService);
+    shipInventoryOrder(id: string): Promise<ShipInventoryOrderDto>;
+    shipInventoryOrders(args: FindShipInventoryOrderArgs): Promise<ShipInventoryOrders>;
+}

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

@@ -0,0 +1,69 @@
+import { __decorate, __param, __metadata } from 'tslib';
+import { Injectable } from '@nestjs/common';
+import { Query, Args, ID } from '@nestjs/graphql';
+import { ShipInventoryOrderService } 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, ShipInventoryOrders } 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 { FindShipInventoryOrderArgs } from '../inputs/find-ship-inventory-order.args.js';
+
+let ShipInventoryOrderQuery = class ShipInventoryOrderQuery {
+    shipInventoryOrderService;
+    constructor(shipInventoryOrderService) {
+        this.shipInventoryOrderService = shipInventoryOrderService;
+    }
+    async shipInventoryOrder(id) {
+        return this.shipInventoryOrderService
+            .selectQueryBuilder('orders')
+            .where('orders.id = :id', { id })
+            .getRawOne();
+    }
+    async shipInventoryOrders(args) {
+        const [items, total] = await this.shipInventoryOrderService.findMany({
+            ...args,
+            wildcard: args.key ? { key: 'key', value: args.key } : undefined,
+        });
+        return { items, total };
+    }
+};
+__decorate([
+    Query(() => ShipInventoryOrderDto),
+    __param(0, Args('id', { type: () => ID })),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], ShipInventoryOrderQuery.prototype, "shipInventoryOrder", null);
+__decorate([
+    Query(() => ShipInventoryOrders),
+    __param(0, Args()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [FindShipInventoryOrderArgs]),
+    __metadata("design:returntype", Promise)
+], ShipInventoryOrderQuery.prototype, "shipInventoryOrders", null);
+ShipInventoryOrderQuery = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [ShipInventoryOrderService])
+], ShipInventoryOrderQuery);
+
+export { ShipInventoryOrderQuery };

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

@@ -0,0 +1,12 @@
+import { StockService } from '@rytass/wms-module-core';
+import { AggregatedStocks, ChangeLogs, Materials, StockDto, Stocks } from '../dto';
+import { FindStockArgs } from '../inputs/find-stock.args';
+export declare class StockQuery {
+    private readonly stockService;
+    constructor(stockService: StockService);
+    stock(id: string): Promise<StockDto>;
+    stocks(args: FindStockArgs): Promise<Stocks>;
+    stocksGroupedByMaterial(args: FindStockArgs): Promise<Materials>;
+    aggregatedStocks(args: FindStockArgs): Promise<AggregatedStocks>;
+    changeLogs(args: FindStockArgs): Promise<ChangeLogs>;
+}

package/lib/queries/stock.query.js

@@ -0,0 +1,109 @@
+import { __decorate, __param, __metadata } from 'tslib';
+import { Injectable } from '@nestjs/common';
+import { Query, Args, ID } from '@nestjs/graphql';
+import { StockService } from '@rytass/wms-module-core';
+import '../dto/loader-type.dto.js';
+import '../dto/loader.dto.js';
+import { Materials } from '../dto/material.dto.js';
+import '../dto/material-unit.dto.js';
+import { StockDto, Stocks, AggregatedStocks, ChangeLogs } 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 { FindStockArgs } from '../inputs/find-stock.args.js';
+
+let StockQuery = class StockQuery {
+    stockService;
+    constructor(stockService) {
+        this.stockService = stockService;
+    }
+    stock(id) {
+        return this.stockService.stockRepository.findOneByOrFail({ id });
+    }
+    async stocks(args) {
+        const [items, total] = await this.stockService.findMany(args);
+        return { items, total };
+    }
+    async stocksGroupedByMaterial(args) {
+        const [items, total] = await this.stockService.findManyGroupedByMaterialId(args);
+        return { items, total };
+    }
+    async aggregatedStocks(args) {
+        const [items, total] = await this.stockService.findAggregatedStocks({
+            ...args,
+            aggregated: true,
+            aggregatedKeys: args.ids?.length ? args.ids : [],
+        });
+        return { items, total };
+    }
+    async changeLogs(args) {
+        const [items, total] = await this.stockService.findChangeLogs({
+            ...args,
+            aggregated: false,
+        });
+        return {
+            items: items.map((item) => ({
+                ...item,
+                quantity: Math.abs(item.quantity),
+            })),
+            total,
+        };
+    }
+};
+__decorate([
+    Query(() => StockDto),
+    __param(0, Args('id', { type: () => ID })),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], StockQuery.prototype, "stock", null);
+__decorate([
+    Query(() => Stocks),
+    __param(0, Args()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [FindStockArgs]),
+    __metadata("design:returntype", Promise)
+], StockQuery.prototype, "stocks", null);
+__decorate([
+    Query(() => Materials),
+    __param(0, Args()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [FindStockArgs]),
+    __metadata("design:returntype", Promise)
+], StockQuery.prototype, "stocksGroupedByMaterial", null);
+__decorate([
+    Query(() => AggregatedStocks),
+    __param(0, Args()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [FindStockArgs]),
+    __metadata("design:returntype", Promise)
+], StockQuery.prototype, "aggregatedStocks", null);
+__decorate([
+    Query(() => ChangeLogs),
+    __param(0, Args()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [FindStockArgs]),
+    __metadata("design:returntype", Promise)
+], StockQuery.prototype, "changeLogs", null);
+StockQuery = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [StockService])
+], StockQuery);
+
+export { StockQuery };

package/lib/queries/transfer-order.query.d.ts

@@ -0,0 +1,9 @@
+import { TransferOrderService } from '@rytass/wms-module-core';
+import { TransferOrderDto, TransferOrders } from '../dto/transfer-order.dto';
+import { FindTransferOrderArgs } from '../inputs/find-transfer-order.args';
+export declare class TransferOrderQuery {
+    private readonly transferOrderService;
+    constructor(transferOrderService: TransferOrderService);
+    transferOrders(args: FindTransferOrderArgs): Promise<TransferOrders>;
+    transferOrder(id: string): Promise<TransferOrderDto>;
+}