@rytass/wms-module-graphql 0.1.0

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

@@ -0,0 +1,42 @@
+import { __decorate, __param, __metadata } from 'tslib';
+import { Injectable } from '@nestjs/common';
+import { Query, Args, ID } from '@nestjs/graphql';
+import { TransferOrderService } from '@rytass/wms-module-core';
+import { TransferOrders, TransferOrderDto } from '../dto/transfer-order.dto.js';
+import { FindTransferOrderArgs } from '../inputs/find-transfer-order.args.js';
+
+let TransferOrderQuery = class TransferOrderQuery {
+    transferOrderService;
+    constructor(transferOrderService) {
+        this.transferOrderService = transferOrderService;
+    }
+    async transferOrders(args) {
+        const [items, total] = await this.transferOrderService.findMany(args);
+        return { items, total };
+    }
+    async transferOrder(id) {
+        return this.transferOrderService.transferOrderRepository.findOneByOrFail({
+            id,
+        });
+    }
+};
+__decorate([
+    Query(() => TransferOrders),
+    __param(0, Args()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [FindTransferOrderArgs]),
+    __metadata("design:returntype", Promise)
+], TransferOrderQuery.prototype, "transferOrders", null);
+__decorate([
+    Query(() => TransferOrderDto),
+    __param(0, Args('id', { type: () => ID })),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], TransferOrderQuery.prototype, "transferOrder", null);
+TransferOrderQuery = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [TransferOrderService])
+], TransferOrderQuery);
+
+export { TransferOrderQuery };

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

@@ -0,0 +1,7 @@
+import { UnitDto } from '../dto/unit.dto';
+import { UnitService } from '@rytass/wms-module-core';
+export declare class UnitQuery {
+    private readonly unitService;
+    constructor(unitService: UnitService);
+    units(): Promise<UnitDto[]>;
+}

package/lib/queries/unit.query.js

@@ -0,0 +1,27 @@
+import { __decorate, __metadata } from 'tslib';
+import { Injectable } from '@nestjs/common';
+import { UnitDto } from '../dto/unit.dto.js';
+import { Query } from '@nestjs/graphql';
+import { UnitService } from '@rytass/wms-module-core';
+
+let UnitQuery = class UnitQuery {
+    unitService;
+    constructor(unitService) {
+        this.unitService = unitService;
+    }
+    units() {
+        return this.unitService.unitRepository.findBy({});
+    }
+};
+__decorate([
+    Query(() => [UnitDto]),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], UnitQuery.prototype, "units", null);
+UnitQuery = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [UnitService])
+], UnitQuery);
+
+export { UnitQuery };

package/lib/queries/warehouse-map.query.d.ts

@@ -0,0 +1,7 @@
+import { MapDataDto } from '../dto/warehouse-map.dto';
+import { WarehouseMapDataService } from '@rytass/wms-module-core';
+export declare class WarehouseMapDataQuery {
+    private readonly warehouseMapDataService;
+    constructor(warehouseMapDataService: WarehouseMapDataService);
+    mapData(key: string): Promise<MapDataDto>;
+}

package/lib/queries/warehouse-map.query.js

@@ -0,0 +1,29 @@
+import { __decorate, __param, __metadata } from 'tslib';
+import { Injectable } from '@nestjs/common';
+import { Query, Args } from '@nestjs/graphql';
+import { MapDataDto } from '../dto/warehouse-map.dto.js';
+import { WarehouseMapDataService } from '@rytass/wms-module-core';
+
+let WarehouseMapDataQuery = class WarehouseMapDataQuery {
+    warehouseMapDataService;
+    constructor(warehouseMapDataService) {
+        this.warehouseMapDataService = warehouseMapDataService;
+    }
+    async mapData(key) {
+        const { mapData } = await this.warehouseMapDataService.warehouseMapDataRepository.findOneByOrFail({ id: key });
+        return mapData;
+    }
+};
+__decorate([
+    Query(() => MapDataDto),
+    __param(0, Args('key')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], WarehouseMapDataQuery.prototype, "mapData", null);
+WarehouseMapDataQuery = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [WarehouseMapDataService])
+], WarehouseMapDataQuery);
+
+export { WarehouseMapDataQuery };

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

@@ -0,0 +1,14 @@
+import { AggregatedStockDto, LoaderDto, MaterialDto } from '../dto';
+import { type LoaderType } from '../helpers';
+import { BatchEntityClass, LoadersEntityClass, LocationEntityClass, MaterialEntityClass, StockService } from '@rytass/wms-module-core';
+import { BatchDto } from '../dto/batch.dto';
+import { LocationDto } from '../dto/location.dto';
+export declare class AggregatedStockResolver {
+    private readonly stockService;
+    constructor(stockService: StockService);
+    id(stock: AggregatedStockDto): Promise<string>;
+    material({ materialId }: AggregatedStockDto, { loaders }: LoaderType<MaterialEntityClass>): Promise<MaterialDto>;
+    batch({ batchId }: AggregatedStockDto, { loaders }: LoaderType<BatchEntityClass>): Promise<BatchDto>;
+    location({ locationId }: AggregatedStockDto, { loaders }: LoaderType<LocationEntityClass>): Promise<LocationDto>;
+    loader({ loaderId }: AggregatedStockDto, { loaders }: LoaderType<LoadersEntityClass>): Promise<LoaderDto>;
+}

package/lib/resolvers/aggregated-stock.resolver.js

@@ -0,0 +1,112 @@
+import { __decorate, __param, __metadata } from 'tslib';
+import { ResolveField, ID, Parent, Context, Resolver } 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 { 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 { StockService, MaterialEntityClass, BatchEntityClass, BatchGroupEntityClass, LocationEntityClass, LoadersEntityClass } from '@rytass/wms-module-core';
+import { BatchDto } from '../dto/batch.dto.js';
+import { LocationDto } from '../dto/location.dto.js';
+
+let AggregatedStockResolver = class AggregatedStockResolver {
+    stockService;
+    constructor(stockService) {
+        this.stockService = stockService;
+    }
+    async id(stock) {
+        return this.stockService.generatedAggregateKey(stock);
+    }
+    async material({ materialId }, { loaders }) {
+        return loaders.batchSingle.load({
+            __entity: MaterialEntityClass,
+            __from: { id: materialId },
+        });
+    }
+    async batch({ batchId }, { loaders }) {
+        const { groupId } = await loaders.batchSingle.load({
+            __entity: BatchEntityClass,
+            __from: { id: batchId },
+        });
+        return loaders.batchSingle.load({
+            __entity: BatchGroupEntityClass,
+            __from: { id: groupId },
+        });
+    }
+    async location({ locationId }, { loaders }) {
+        return loaders.batchSingle.load({
+            __entity: LocationEntityClass,
+            __from: { id: locationId },
+        });
+    }
+    async loader({ loaderId }, { loaders }) {
+        return loaders.batchSingle.load({
+            __entity: LoadersEntityClass,
+            __from: { id: loaderId },
+        });
+    }
+};
+__decorate([
+    ResolveField(() => ID),
+    __param(0, Parent()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [AggregatedStockDto]),
+    __metadata("design:returntype", Promise)
+], AggregatedStockResolver.prototype, "id", null);
+__decorate([
+    ResolveField(() => MaterialDto),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [AggregatedStockDto, Object]),
+    __metadata("design:returntype", Promise)
+], AggregatedStockResolver.prototype, "material", null);
+__decorate([
+    ResolveField(() => BatchDto),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [AggregatedStockDto, Object]),
+    __metadata("design:returntype", Promise)
+], AggregatedStockResolver.prototype, "batch", null);
+__decorate([
+    ResolveField(() => LocationDto),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [AggregatedStockDto, Object]),
+    __metadata("design:returntype", Promise)
+], AggregatedStockResolver.prototype, "location", null);
+__decorate([
+    ResolveField(() => LoaderDto),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [AggregatedStockDto, Object]),
+    __metadata("design:returntype", Promise)
+], AggregatedStockResolver.prototype, "loader", null);
+AggregatedStockResolver = __decorate([
+    Resolver(() => AggregatedStockDto),
+    __metadata("design:paramtypes", [StockService])
+], AggregatedStockResolver);
+
+export { AggregatedStockResolver };

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

@@ -0,0 +1,6 @@
+import { AllocateInventoryOrderItemDto } from '../dto/allocate-inventory-order-item.dto';
+import { AllocateInventoryOrderEntityClass, AllocateInventoryOrderItemEntityClass } from '@rytass/wms-module-core';
+import { type LoaderType } from '../helpers';
+export declare class AllocateInventoryOrderResolver {
+    items({ id }: AllocateInventoryOrderEntityClass, { loaders }: LoaderType<AllocateInventoryOrderItemEntityClass>): Promise<AllocateInventoryOrderItemDto[]>;
+}

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

@@ -0,0 +1,27 @@
+import { __decorate, __param, __metadata } from 'tslib';
+import { ResolveField, Parent, Context, Resolver } from '@nestjs/graphql';
+import { AllocateInventoryOrderDto } from '../dto/allocate-inventory-order.dto.js';
+import { AllocateInventoryOrderItemDto } from '../dto/allocate-inventory-order-item.dto.js';
+import { AllocateInventoryOrderEntityClass, AllocateInventoryOrderItemEntityClass } from '@rytass/wms-module-core';
+
+let AllocateInventoryOrderResolver = class AllocateInventoryOrderResolver {
+    items({ id }, { loaders }) {
+        return loaders.batchMany.load({
+            __entity: AllocateInventoryOrderItemEntityClass,
+            __from: { orderId: id },
+        });
+    }
+};
+__decorate([
+    ResolveField(() => [AllocateInventoryOrderItemDto]),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [AllocateInventoryOrderEntityClass, Object]),
+    __metadata("design:returntype", Promise)
+], AllocateInventoryOrderResolver.prototype, "items", null);
+AllocateInventoryOrderResolver = __decorate([
+    Resolver(() => AllocateInventoryOrderDto)
+], AllocateInventoryOrderResolver);
+
+export { AllocateInventoryOrderResolver };

package/lib/resolvers/change-log.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 ChangeLogResolver {
+    material({ materialId }: StockEntityClass, { loaders }: LoaderType<MaterialEntityClass>): Promise<MaterialDto>;
+    location({ locationId }: StockEntityClass, { loaders }: LoaderType<LocationEntityClass>): Promise<LocationDto>;
+    batch({ batchId }: StockEntityClass, { loaders }: LoaderType<BatchEntityClass>): Promise<BatchDto>;
+}

package/lib/resolvers/change-log.resolver.js

@@ -0,0 +1,83 @@
+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 '../dto/material-unit.dto.js';
+import { ChangeLogDto } 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 { StockEntityClass, MaterialEntityClass, LocationEntityClass, BatchEntityClass, BatchGroupEntityClass } from '@rytass/wms-module-core';
+import { LocationDto } from '../dto/location.dto.js';
+import { BatchDto } from '../dto/batch.dto.js';
+
+let ChangeLogResolver = class ChangeLogResolver {
+    material({ materialId }, { loaders }) {
+        return loaders.batchSingle.load({
+            __entity: MaterialEntityClass,
+            __from: { id: materialId },
+        });
+    }
+    location({ locationId }, { loaders }) {
+        return loaders.batchSingle.load({
+            __entity: LocationEntityClass,
+            __from: { id: locationId },
+        });
+    }
+    async batch({ batchId }, { loaders }) {
+        const { groupId } = await loaders.batchSingle.load({
+            __entity: BatchEntityClass,
+            __from: { id: batchId },
+        });
+        return loaders.batchSingle.load({
+            __entity: BatchGroupEntityClass,
+            __from: { id: groupId },
+        });
+    }
+};
+__decorate([
+    ResolveField(() => MaterialDto),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [StockEntityClass, Object]),
+    __metadata("design:returntype", Promise)
+], ChangeLogResolver.prototype, "material", null);
+__decorate([
+    ResolveField(() => LocationDto),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [StockEntityClass, Object]),
+    __metadata("design:returntype", Promise)
+], ChangeLogResolver.prototype, "location", null);
+__decorate([
+    ResolveField(() => BatchDto),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [StockEntityClass, Object]),
+    __metadata("design:returntype", Promise)
+], ChangeLogResolver.prototype, "batch", null);
+ChangeLogResolver = __decorate([
+    Resolver(() => ChangeLogDto)
+], ChangeLogResolver);
+
+export { ChangeLogResolver };

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

@@ -0,0 +1,7 @@
+import { HoldInventoryOrderDto } from '../dto/hold-inventory-order.dto';
+import { HoldInventoryOrderItemDto } from '../dto/hold-inventory-order-item.dto';
+import { type LoaderType } from '../helpers';
+import { HoldInventoryOrderItemEntityClass } from '@rytass/wms-module-core';
+export declare class HoldInventoryOrderResolver {
+    items({ id }: HoldInventoryOrderDto, { loaders }: LoaderType<HoldInventoryOrderItemEntityClass>): Promise<HoldInventoryOrderItemDto[]>;
+}

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

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

package/lib/resolvers/loader-type.resolver.d.ts

@@ -0,0 +1,5 @@
+import { LoadersEntityClass, LoaderTypeEntityClass } from '@rytass/wms-module-core';
+import { type LoaderType } from '../helpers';
+export declare class LoaderTypeResolver {
+    referencedQuantity({ id }: LoaderTypeEntityClass, { loaders }: LoaderType<LoadersEntityClass>): Promise<number>;
+}

package/lib/resolvers/loader-type.resolver.js

@@ -0,0 +1,50 @@
+import { __decorate, __param, __metadata } from 'tslib';
+import { ResolveField, Int, Parent, Context, Resolver } from '@nestjs/graphql';
+import { LoaderTypeDto } from '../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 '../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 { LoaderTypeEntityClass, LoadersEntityClass } from '@rytass/wms-module-core';
+
+let LoaderTypeResolver = class LoaderTypeResolver {
+    async referencedQuantity({ id }, { loaders }) {
+        const referenced = await loaders.batchMany.load({
+            __entity: LoadersEntityClass,
+            __from: { typeId: id },
+        });
+        return referenced.length;
+    }
+};
+__decorate([
+    ResolveField(() => Int),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [LoaderTypeEntityClass, Object]),
+    __metadata("design:returntype", Promise)
+], LoaderTypeResolver.prototype, "referencedQuantity", null);
+LoaderTypeResolver = __decorate([
+    Resolver(() => LoaderTypeDto)
+], LoaderTypeResolver);
+
+export { LoaderTypeResolver };

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

@@ -0,0 +1,9 @@
+import { LoadersEntityClass, LoaderTypeEntityClass, LocationEntityClass, StockService } from '@rytass/wms-module-core';
+import { type LoaderType } from '../helpers';
+export declare class LoaderResolver {
+    private readonly stockService;
+    constructor(stockService: StockService);
+    type({ typeId }: LoadersEntityClass, { loaders }: LoaderType<LoaderTypeEntityClass>): Promise<LoaderTypeEntityClass>;
+    location({ locationId }: LoadersEntityClass, { loaders }: LoaderType<LocationEntityClass>): Promise<LocationEntityClass>;
+    totalQuantity({ id }: LoadersEntityClass): Promise<number>;
+}

package/lib/resolvers/loader.resolver.js

@@ -0,0 +1,86 @@
+import { __decorate, __param, __metadata } from 'tslib';
+import { ResolveField, Parent, Context, Int, Resolver } from '@nestjs/graphql';
+import { LoaderTypeDto } from '../dto/loader-type.dto.js';
+import { LoaderDto } 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 { LoadersEntityClass, StockService, LoaderTypeEntityClass, LocationEntityClass } from '@rytass/wms-module-core';
+import { LocationDto } from '../dto/location.dto.js';
+import _ from 'lodash';
+
+let LoaderResolver = class LoaderResolver {
+    stockService;
+    constructor(stockService) {
+        this.stockService = stockService;
+    }
+    type({ typeId }, { loaders }) {
+        return loaders.batchSingle.load({
+            __entity: LoaderTypeEntityClass,
+            __from: { id: typeId },
+        });
+    }
+    location({ locationId }, { loaders }) {
+        return loaders.batchSingle.load({
+            __entity: LocationEntityClass,
+            __from: { id: locationId },
+        });
+    }
+    async totalQuantity({ id }) {
+        const [aggregatedStocks] = await this.stockService.findAggregatedStocks({
+            loaderId: id,
+            aggregated: true,
+        });
+        if (!aggregatedStocks.length)
+            return 0;
+        return aggregatedStocks.reduce((total, { quantity }) => total + _.toInteger(quantity), 0);
+    }
+};
+__decorate([
+    ResolveField(() => LoaderTypeDto),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [LoadersEntityClass, Object]),
+    __metadata("design:returntype", void 0)
+], LoaderResolver.prototype, "type", null);
+__decorate([
+    ResolveField(() => LocationDto),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [LoadersEntityClass, Object]),
+    __metadata("design:returntype", void 0)
+], LoaderResolver.prototype, "location", null);
+__decorate([
+    ResolveField(() => Int),
+    __param(0, Parent()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [LoadersEntityClass]),
+    __metadata("design:returntype", Promise)
+], LoaderResolver.prototype, "totalQuantity", null);
+LoaderResolver = __decorate([
+    Resolver(() => LoaderDto),
+    __metadata("design:paramtypes", [StockService])
+], LoaderResolver);
+
+export { LoaderResolver };

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

@@ -0,0 +1,10 @@
+import { LocationDto } from '../dto/location.dto';
+import { MapDataDto } from '../dto/warehouse-map.dto';
+import { type LoaderType } from '../helpers';
+import { WarehouseMapEntity } from '@rytass/wms-base-nestjs-module/models/warehouse-map.entity';
+import { LocationEntityClass } from '@rytass/wms-module-core';
+export declare class LocationResolver {
+    mapData({ id }: LocationDto, { loaders }: LoaderType<WarehouseMapEntity>): Promise<MapDataDto | null>;
+    parent({ parentId }: LocationEntityClass, { loaders }: LoaderType<LocationEntityClass>): Promise<LocationEntityClass> | null;
+    children({ children }: LocationEntityClass): import("@rytass/wms-base-nestjs-module").LocationEntity[];
+}

package/lib/resolvers/location.resolver.js

@@ -0,0 +1,55 @@
+import { __decorate, __param, __metadata } from 'tslib';
+import { ResolveField, Parent, Context, Resolver } from '@nestjs/graphql';
+import { LocationDto } from '../dto/location.dto.js';
+import { MapDataDto } from '../dto/warehouse-map.dto.js';
+import { WarehouseMapEntity } from '@rytass/wms-base-nestjs-module/models/warehouse-map.entity';
+import { LocationEntityClass } from '@rytass/wms-module-core';
+
+let LocationResolver = class LocationResolver {
+    async mapData({ id }, { loaders }) {
+        const map = await loaders.batchSingle.load({
+            __entity: WarehouseMapEntity,
+            __from: { id },
+        });
+        return map?.mapData || null;
+    }
+    parent({ parentId }, { loaders }) {
+        if (!parentId)
+            return null;
+        return loaders.batchSingle.load({
+            __entity: LocationEntityClass,
+            __from: { id: parentId },
+        });
+    }
+    children({ children }) {
+        return children;
+    }
+};
+__decorate([
+    ResolveField(() => MapDataDto, { nullable: true }),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [LocationDto, Object]),
+    __metadata("design:returntype", Promise)
+], LocationResolver.prototype, "mapData", null);
+__decorate([
+    ResolveField(() => LocationDto, { nullable: true }),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [LocationEntityClass, Object]),
+    __metadata("design:returntype", void 0)
+], LocationResolver.prototype, "parent", null);
+__decorate([
+    ResolveField(() => [LocationDto]),
+    __param(0, Parent()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [LocationEntityClass]),
+    __metadata("design:returntype", void 0)
+], LocationResolver.prototype, "children", null);
+LocationResolver = __decorate([
+    Resolver(() => LocationDto)
+], LocationResolver);
+
+export { LocationResolver };

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

@@ -0,0 +1,11 @@
+import { AggregatedStockDto } from '../dto';
+import { MaterialEntityClass, MaterialUnitEntityClass, StockService, UnitEntityClass } from '@rytass/wms-module-core';
+import { type LoaderType } from '../helpers';
+import { UnitDto } from '../dto/unit.dto';
+export declare class MaterialResolver {
+    private readonly stockService;
+    constructor(stockService: StockService);
+    aggregatedStock({ id }: MaterialEntityClass): Promise<AggregatedStockDto[]>;
+    materialUnits({ id }: MaterialEntityClass, { loaders }: LoaderType<MaterialUnitEntityClass>): Promise<MaterialUnitEntityClass[]>;
+    baseUnit({ baseUnit }: MaterialEntityClass, { loaders }: LoaderType<UnitEntityClass>): Promise<UnitDto>;
+}