@rytass/wms-module-graphql 0.7.0 → 0.9.0

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

@@ -1,5 +1,4 @@
 import { __decorate, __param, __metadata } from 'tslib';
-import { Inject } from '@nestjs/common';
 import { ResolveField, Parent, Context, Resolver } from '@nestjs/graphql';
 import '../dto/loader-type.dto.js';
 import '../dto/loader.dto.js';
@@ -25,37 +24,38 @@ 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, MaterialEntity, LocationEntityClass, BatchEntityClass, BatchGroupEntityClass } from '@rytass/wms-module-core';
+import '../dto/inventory-count-order.dto.js';
+import { StockEntityClass, WmsEntities, BatchGroupEntityClass } from '@rytass/wms-module-core';
 import { LocationDto } from '../dto/location.dto.js';
 import { BatchDto } from '../dto/batch.dto.js';
 
 let ChangeLogResolver = class ChangeLogResolver {
-    materialEntity;
+    entities;
     /**
-     * Bound to the `MaterialEntity` Symbol, so the DataLoader queries whichever
-     * material entity the consumer configured — the built-in `MaterialEntityClass`
-     * unless `materialEntity` was passed to `forRoot`/`forRootAsync`. Loading the
-     * built-in class outright would filter on its single-table-inheritance
-     * discriminator and resolve nothing for a custom entity.
+     * The configured entities, not the built-in classes: `__entity` decides which
+     * repository the DataLoader opens, so it has to follow whatever the consumer
+     * passed to `WMSBaseModuleOptions`. Loading a built-in class outright filters
+     * on its single-table-inheritance discriminator and resolves nothing for an
+     * override.
      */
-    constructor(materialEntity) {
-        this.materialEntity = materialEntity;
+    constructor(entities) {
+        this.entities = entities;
     }
     material({ materialId }, { loaders }) {
         return loaders.batchSingle.load({
-            __entity: this.materialEntity,
+            __entity: this.entities.material,
             __from: { id: materialId },
         });
     }
     location({ locationId }, { loaders }) {
         return loaders.batchSingle.load({
-            __entity: LocationEntityClass,
+            __entity: this.entities.location,
             __from: { id: locationId },
         });
     }
     async batch({ batchId }, { loaders }) {
         const { groupId } = await loaders.batchSingle.load({
-            __entity: BatchEntityClass,
+            __entity: this.entities.batch,
             __from: { id: batchId },
         });
         return loaders.batchSingle.load({
@@ -90,8 +90,7 @@ __decorate([
 ], ChangeLogResolver.prototype, "batch", null);
 ChangeLogResolver = __decorate([
     Resolver(() => ChangeLogDto),
-    __param(0, Inject(MaterialEntity)),
-    __metadata("design:paramtypes", [Function])
+    __metadata("design:paramtypes", [WmsEntities])
 ], ChangeLogResolver);
 
 export { ChangeLogResolver };

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

@@ -0,0 +1,34 @@
+import { BatchEntityClass, InventoryCountOrderItemEntityClass, InventoryCountOrderLocationEntityClass, LoadersEntityClass, LocationEntityClass, MaterialEntityClass, WmsEntities } from '@rytass/wms-module-core';
+import { InventoryCountOrderDto, InventoryCountOrderItemDto } from '../dto/inventory-count-order.dto';
+import { BatchDto } from '../dto/batch.dto';
+import { LoaderDto } from '../dto/loader.dto';
+import { LocationDto } from '../dto/location.dto';
+import { MaterialDto } from '../dto/material.dto';
+import { type LoaderType } from '../helpers';
+export declare class InventoryCountOrderResolver {
+    private readonly entities;
+    constructor(entities: WmsEntities);
+    items({ id }: InventoryCountOrderDto, { loaders }: LoaderType<InventoryCountOrderItemEntityClass>): Promise<InventoryCountOrderItemDto[]>;
+    /**
+     * The locations the user picked.
+     *
+     * Only the roots: the scope table also holds every descendant the backend
+     * expanded into, and listing a whole aisle's shelves as chips would bury the
+     * one thing the operator actually chose. The expansion still exists in the
+     * database — it is what the lock reads — it just is not this field.
+     */
+    locations({ id }: InventoryCountOrderDto, { loaders }: LoaderType<InventoryCountOrderLocationEntityClass>): Promise<LocationDto[]>;
+}
+export declare class InventoryCountOrderItemResolver {
+    private readonly entities;
+    /**
+     * The configured entities, not the built-in classes: `__entity` decides which
+     * repository the DataLoader opens, so it has to follow whatever the consumer
+     * passed to `WMSBaseModuleOptions`.
+     */
+    constructor(entities: WmsEntities);
+    material({ materialId }: InventoryCountOrderItemDto, { loaders }: LoaderType<MaterialEntityClass>): Promise<MaterialDto>;
+    batch({ batchId }: InventoryCountOrderItemDto, { loaders }: LoaderType<BatchEntityClass>): Promise<BatchDto>;
+    location({ locationId }: InventoryCountOrderItemDto, { loaders }: LoaderType<LocationEntityClass>): Promise<LocationDto> | null;
+    loader({ loaderId }: InventoryCountOrderItemDto, { loaders }: LoaderType<LoadersEntityClass>): Promise<LoaderDto> | null;
+}

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

@@ -0,0 +1,148 @@
+import { __decorate, __param, __metadata } from 'tslib';
+import { ResolveField, Parent, Context, Resolver } from '@nestjs/graphql';
+import { WmsEntities, InventoryCountOrderItemEntityClass, InventoryCountOrderLocationEntityClass, BatchGroupEntityClass, LoadersEntityClass } from '@rytass/wms-module-core';
+import { InventoryCountOrderItemDto, InventoryCountOrderDto } from '../dto/inventory-count-order.dto.js';
+import { BatchDto } from '../dto/batch.dto.js';
+import { LoaderDto } from '../dto/loader.dto.js';
+import { LocationDto } from '../dto/location.dto.js';
+import { MaterialDto } from '../dto/material.dto.js';
+
+let InventoryCountOrderResolver = class InventoryCountOrderResolver {
+    entities;
+    constructor(entities) {
+        this.entities = entities;
+    }
+    items({ id }, { loaders }) {
+        return loaders.batchMany.load({
+            __entity: InventoryCountOrderItemEntityClass,
+            __from: { orderId: id },
+        });
+    }
+    /**
+     * The locations the user picked.
+     *
+     * Only the roots: the scope table also holds every descendant the backend
+     * expanded into, and listing a whole aisle's shelves as chips would bury the
+     * one thing the operator actually chose. The expansion still exists in the
+     * database — it is what the lock reads — it just is not this field.
+     */
+    async locations({ id }, { loaders }) {
+        const scope = (await loaders.batchMany.load({
+            __entity: InventoryCountOrderLocationEntityClass,
+            __from: { orderId: id },
+        }));
+        // The join rows carry `locationId`, not a loaded `location` relation, so
+        // each one has to go back through the location DataLoader. Returning
+        // `row.location` directly yields `undefined`, and the non-nullable list then
+        // fails the whole query with "Cannot return null for non-nullable field".
+        return Promise.all(scope
+            .filter(({ isRoot }) => isRoot)
+            .map(({ locationId }) => loaders.batchSingle.load({
+            __entity: this.entities.location,
+            __from: { id: locationId },
+        })));
+    }
+};
+__decorate([
+    ResolveField(() => [InventoryCountOrderItemDto]),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [InventoryCountOrderDto, Object]),
+    __metadata("design:returntype", Promise)
+], InventoryCountOrderResolver.prototype, "items", null);
+__decorate([
+    ResolveField(() => [LocationDto]),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [InventoryCountOrderDto, Object]),
+    __metadata("design:returntype", Promise)
+], InventoryCountOrderResolver.prototype, "locations", null);
+InventoryCountOrderResolver = __decorate([
+    Resolver(() => InventoryCountOrderDto),
+    __metadata("design:paramtypes", [WmsEntities])
+], InventoryCountOrderResolver);
+let InventoryCountOrderItemResolver = class InventoryCountOrderItemResolver {
+    entities;
+    /**
+     * The configured entities, not the built-in classes: `__entity` decides which
+     * repository the DataLoader opens, so it has to follow whatever the consumer
+     * passed to `WMSBaseModuleOptions`.
+     */
+    constructor(entities) {
+        this.entities = entities;
+    }
+    material({ materialId }, { loaders }) {
+        return loaders.batchSingle.load({
+            __entity: this.entities.material,
+            __from: { id: materialId },
+        });
+    }
+    async batch({ batchId }, { loaders }) {
+        const { groupId } = await loaders.batchSingle.load({
+            __entity: this.entities.batch,
+            __from: { id: batchId },
+        });
+        return loaders.batchSingle.load({
+            __entity: BatchGroupEntityClass,
+            __from: { id: groupId },
+        });
+    }
+    location({ locationId }, { loaders }) {
+        if (!locationId) {
+            return null;
+        }
+        return loaders.batchSingle.load({
+            __entity: this.entities.location,
+            __from: { id: locationId },
+        });
+    }
+    loader({ loaderId }, { loaders }) {
+        if (!loaderId) {
+            return null;
+        }
+        return loaders.batchSingle.load({
+            __entity: LoadersEntityClass,
+            __from: { id: loaderId },
+        });
+    }
+};
+__decorate([
+    ResolveField(() => MaterialDto),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [InventoryCountOrderItemDto, Object]),
+    __metadata("design:returntype", Promise)
+], InventoryCountOrderItemResolver.prototype, "material", null);
+__decorate([
+    ResolveField(() => BatchDto),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [InventoryCountOrderItemDto, Object]),
+    __metadata("design:returntype", Promise)
+], InventoryCountOrderItemResolver.prototype, "batch", null);
+__decorate([
+    ResolveField(() => LocationDto, { nullable: true }),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [InventoryCountOrderItemDto, Object]),
+    __metadata("design:returntype", Object)
+], InventoryCountOrderItemResolver.prototype, "location", null);
+__decorate([
+    ResolveField(() => LoaderDto, { nullable: true }),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [InventoryCountOrderItemDto, Object]),
+    __metadata("design:returntype", Object)
+], InventoryCountOrderItemResolver.prototype, "loader", null);
+InventoryCountOrderItemResolver = __decorate([
+    Resolver(() => InventoryCountOrderItemDto),
+    __metadata("design:paramtypes", [WmsEntities])
+], InventoryCountOrderItemResolver);
+
+export { InventoryCountOrderItemResolver, InventoryCountOrderResolver };

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

@@ -24,6 +24,7 @@ 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 '../dto/inventory-count-order.dto.js';
 import { LoaderTypeEntityClass, LoadersEntityClass } from '@rytass/wms-module-core';
 
 let LoaderTypeResolver = class LoaderTypeResolver {

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

@@ -1,8 +1,16 @@
-import { LoadersEntityClass, LoaderTypeEntityClass, LocationEntityClass, StockService } from '@rytass/wms-module-core';
+import { LoaderTypeEntityClass, LoadersEntityClass, LocationEntityClass, StockService, WmsEntities } from '@rytass/wms-module-core';
 import { type LoaderType } from '../helpers';
 export declare class LoaderResolver {
+    private readonly entities;
     private readonly stockService;
-    constructor(stockService: StockService);
+    /**
+     * The configured entities, not the built-in classes: `__entity` decides which
+     * repository the DataLoader opens, so it has to follow whatever the consumer
+     * passed to `WMSBaseModuleOptions`. Loading a built-in class outright filters
+     * on its single-table-inheritance discriminator and resolves nothing for an
+     * override.
+     */
+    constructor(entities: WmsEntities, 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

@@ -24,13 +24,23 @@ 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 '../dto/inventory-count-order.dto.js';
+import { LoadersEntityClass, WmsEntities, StockService, LoaderTypeEntityClass } from '@rytass/wms-module-core';
 import { LocationDto } from '../dto/location.dto.js';
 import _ from 'lodash';
 
 let LoaderResolver = class LoaderResolver {
+    entities;
     stockService;
-    constructor(stockService) {
+    /**
+     * The configured entities, not the built-in classes: `__entity` decides which
+     * repository the DataLoader opens, so it has to follow whatever the consumer
+     * passed to `WMSBaseModuleOptions`. Loading a built-in class outright filters
+     * on its single-table-inheritance discriminator and resolves nothing for an
+     * override.
+     */
+    constructor(entities, stockService) {
+        this.entities = entities;
         this.stockService = stockService;
     }
     type({ typeId }, { loaders }) {
@@ -41,7 +51,7 @@ let LoaderResolver = class LoaderResolver {
     }
     location({ locationId }, { loaders }) {
         return loaders.batchSingle.load({
-            __entity: LocationEntityClass,
+            __entity: this.entities.location,
             __from: { id: locationId },
         });
     }
@@ -80,7 +90,8 @@ __decorate([
 ], LoaderResolver.prototype, "totalQuantity", null);
 LoaderResolver = __decorate([
     Resolver(() => LoaderDto),
-    __metadata("design:paramtypes", [StockService])
+    __metadata("design:paramtypes", [WmsEntities,
+        StockService])
 ], LoaderResolver);
 
 export { LoaderResolver };

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

@@ -2,8 +2,17 @@ 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';
+import { LocationEntityClass, WmsEntities } from '@rytass/wms-module-core';
 export declare class LocationResolver {
+    private readonly entities;
+    /**
+     * The configured entities, not the built-in classes: `__entity` decides which
+     * repository the DataLoader opens, so it has to follow whatever the consumer
+     * passed to `WMSBaseModuleOptions`. Loading a built-in class outright filters
+     * on its single-table-inheritance discriminator and resolves nothing for an
+     * override.
+     */
+    constructor(entities: WmsEntities);
     mapData({ id }: LocationDto, { loaders }: LoaderType<WarehouseMapEntity>): Promise<MapDataDto | null>;
     parent({ parentId }: LocationEntityClass, { loaders }: LoaderType<LocationEntityClass>): Promise<LocationEntityClass> | null;
     /**

package/lib/resolvers/location.resolver.js

@@ -2,13 +2,23 @@ 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';
+import { LocationEntityClass, WmsEntities } from '@rytass/wms-module-core';
 
 let LocationResolver = class LocationResolver {
+    entities;
+    /**
+     * The configured entities, not the built-in classes: `__entity` decides which
+     * repository the DataLoader opens, so it has to follow whatever the consumer
+     * passed to `WMSBaseModuleOptions`. Loading a built-in class outright filters
+     * on its single-table-inheritance discriminator and resolves nothing for an
+     * override.
+     */
+    constructor(entities) {
+        this.entities = entities;
+    }
     async mapData({ id }, { loaders }) {
         const map = await loaders.batchSingle.load({
-            __entity: WarehouseMapEntity,
+            __entity: this.entities.warehouseMap,
             __from: { id },
         });
         return map?.mapData || null;
@@ -17,7 +27,7 @@ let LocationResolver = class LocationResolver {
         if (!parentId)
             return null;
         return loaders.batchSingle.load({
-            __entity: LocationEntityClass,
+            __entity: this.entities.location,
             __from: { id: parentId },
         });
     }
@@ -32,7 +42,7 @@ let LocationResolver = class LocationResolver {
      */
     children({ id }, { loaders }) {
         return loaders.batchMany.load({
-            __entity: LocationEntityClass,
+            __entity: this.entities.location,
             __from: { parentId: id },
             __conditions: (qb) => qb.orderBy('entity."key"', 'ASC'),
         });
@@ -63,7 +73,8 @@ __decorate([
     __metadata("design:returntype", Promise)
 ], LocationResolver.prototype, "children", null);
 LocationResolver = __decorate([
-    Resolver(() => LocationDto)
+    Resolver(() => LocationDto),
+    __metadata("design:paramtypes", [WmsEntities])
 ], LocationResolver);
 
 export { LocationResolver };

package/lib/resolvers/material.resolver.js

@@ -24,6 +24,7 @@ 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 '../dto/inventory-count-order.dto.js';
 import { MaterialEntityClass, StockService, MaterialUnitEntityClass, UnitEntityClass } from '@rytass/wms-module-core';
 import { UnitDto } from '../dto/unit.dto.js';
 

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

@@ -1,21 +1,21 @@
 import { LoaderDto, MaterialDto, ReceiveInventoryOrderDto, ReceiveInventoryOrderItemDto } from '../dto';
 import { type LoaderType } from '../helpers';
-import { BatchEntityClass, LoadersEntityClass, LocationEntityClass, MaterialEntityClass, ReceiveInventoryOrderChangeEntityClass, ReceiveInventoryOrderItemEntityClass } from '@rytass/wms-module-core';
+import { BatchEntityClass, LoadersEntityClass, LocationEntityClass, MaterialEntityClass, ReceiveInventoryOrderChangeEntityClass, ReceiveInventoryOrderItemEntityClass, WmsEntities } from '@rytass/wms-module-core';
 import { BatchDto } from '../dto/batch.dto';
 import { LocationDto } from '../dto/location.dto';
 export declare class ReceiveInventoryOrderResolver {
     items({ id }: ReceiveInventoryOrderDto, { loaders }: LoaderType<ReceiveInventoryOrderItemEntityClass>): Promise<ReceiveInventoryOrderItemDto[]>;
 }
 export declare class ReceiveInventoryOrderItemResolver {
-    private readonly materialEntity;
+    private readonly entities;
     /**
-     * Bound to the `MaterialEntity` Symbol, so the DataLoader queries whichever
-     * material entity the consumer configured — the built-in `MaterialEntityClass`
-     * unless `materialEntity` was passed to `forRoot`/`forRootAsync`. Loading the
-     * built-in class outright would filter on its single-table-inheritance
-     * discriminator and resolve nothing for a custom entity.
+     * The configured entities, not the built-in classes: `__entity` decides which
+     * repository the DataLoader opens, so it has to follow whatever the consumer
+     * passed to `WMSBaseModuleOptions`. Loading a built-in class outright filters
+     * on its single-table-inheritance discriminator and resolves nothing for an
+     * override.
      */
-    constructor(materialEntity: new () => MaterialEntityClass);
+    constructor(entities: WmsEntities);
     material({ materialId }: ReceiveInventoryOrderItemEntityClass, { loaders }: LoaderType<MaterialEntityClass>): Promise<MaterialDto>;
     batch({ batchId }: ReceiveInventoryOrderItemEntityClass, { loaders }: LoaderType<BatchEntityClass>): Promise<BatchDto | null>;
     location({ locationId }: ReceiveInventoryOrderItemEntityClass, { loaders }: LoaderType<LocationEntityClass>): Promise<LocationDto | null>;

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

@@ -1,5 +1,4 @@
 import { __decorate, __param, __metadata } from 'tslib';
-import { Inject } from '@nestjs/common';
 import { ResolveField, Parent, Context, Resolver, Int } from '@nestjs/graphql';
 import '../dto/loader-type.dto.js';
 import { LoaderDto } from '../dto/loader.dto.js';
@@ -25,7 +24,8 @@ import '../dto/scrape-order.dto.js';
 import '../dto/scrape-order-item.dto.js';
 import '../dto/quality-inspection-order.dto.js';
 import '../dto/quality-inspection-order-item.dto.js';
-import { ReceiveInventoryOrderItemEntityClass, MaterialEntity, BatchEntityClass, BatchGroupEntityClass, LocationEntityClass, LoadersEntityClass, ReceiveInventoryOrderChangeEntityClass } from '@rytass/wms-module-core';
+import '../dto/inventory-count-order.dto.js';
+import { ReceiveInventoryOrderItemEntityClass, WmsEntities, BatchGroupEntityClass, LoadersEntityClass, ReceiveInventoryOrderChangeEntityClass } from '@rytass/wms-module-core';
 import { BatchDto } from '../dto/batch.dto.js';
 import { LocationDto } from '../dto/location.dto.js';
 
@@ -50,20 +50,20 @@ ReceiveInventoryOrderResolver = __decorate([
     Resolver(() => ReceiveInventoryOrderDto)
 ], ReceiveInventoryOrderResolver);
 let ReceiveInventoryOrderItemResolver = class ReceiveInventoryOrderItemResolver {
-    materialEntity;
+    entities;
     /**
-     * Bound to the `MaterialEntity` Symbol, so the DataLoader queries whichever
-     * material entity the consumer configured — the built-in `MaterialEntityClass`
-     * unless `materialEntity` was passed to `forRoot`/`forRootAsync`. Loading the
-     * built-in class outright would filter on its single-table-inheritance
-     * discriminator and resolve nothing for a custom entity.
+     * The configured entities, not the built-in classes: `__entity` decides which
+     * repository the DataLoader opens, so it has to follow whatever the consumer
+     * passed to `WMSBaseModuleOptions`. Loading a built-in class outright filters
+     * on its single-table-inheritance discriminator and resolves nothing for an
+     * override.
      */
-    constructor(materialEntity) {
-        this.materialEntity = materialEntity;
+    constructor(entities) {
+        this.entities = entities;
     }
     material({ materialId }, { loaders }) {
         return loaders.batchSingle.load({
-            __entity: this.materialEntity,
+            __entity: this.entities.material,
             __from: { id: materialId },
         });
     }
@@ -71,7 +71,7 @@ let ReceiveInventoryOrderItemResolver = class ReceiveInventoryOrderItemResolver
         if (!batchId)
             return null;
         const { groupId } = await loaders.batchSingle.load({
-            __entity: BatchEntityClass,
+            __entity: this.entities.batch,
             __from: { id: batchId },
         });
         return loaders.batchSingle.load({
@@ -83,7 +83,7 @@ let ReceiveInventoryOrderItemResolver = class ReceiveInventoryOrderItemResolver
         if (!locationId)
             return null;
         return loaders.batchSingle.load({
-            __entity: LocationEntityClass,
+            __entity: this.entities.location,
             __from: { id: locationId },
         });
     }
@@ -147,8 +147,7 @@ __decorate([
 ], ReceiveInventoryOrderItemResolver.prototype, "receivedQuantity", null);
 ReceiveInventoryOrderItemResolver = __decorate([
     Resolver(() => ReceiveInventoryOrderItemDto),
-    __param(0, Inject(MaterialEntity)),
-    __metadata("design:paramtypes", [Function])
+    __metadata("design:paramtypes", [WmsEntities])
 ], ReceiveInventoryOrderItemResolver);
 
 export { ReceiveInventoryOrderItemResolver, ReceiveInventoryOrderResolver };

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

@@ -1,5 +1,5 @@
 import { LoaderDto, MaterialDto, ShipInventoryOrderItemDto } from '../dto';
-import { BatchEntityClass, LoadersEntityClass, LocationEntityClass, MaterialEntityClass, ShipInventoryOrderChangeEntityClass, ShipInventoryOrderEntityClass, ShipInventoryOrderItemEntityClass, ShipInventoryOrderReferenceEntityClass } from '@rytass/wms-module-core';
+import { BatchEntityClass, LoadersEntityClass, LocationEntityClass, MaterialEntityClass, ShipInventoryOrderChangeEntityClass, ShipInventoryOrderEntityClass, ShipInventoryOrderItemEntityClass, ShipInventoryOrderReferenceEntityClass, WmsEntities } from '@rytass/wms-module-core';
 import { type LoaderType } from '../helpers';
 import { BatchDto } from '../dto/batch.dto';
 import { LocationDto } from '../dto/location.dto';
@@ -9,15 +9,15 @@ export declare class ShipInventoryOrderResolver {
     references({ id }: ShipInventoryOrderEntityClass, { loaders }: LoaderType<ShipInventoryOrderReferenceEntityClass>): Promise<ShipInventoryOrderReferenceDto[]>;
 }
 export declare class ShipInventoryOrderItemResolver {
-    private readonly materialEntity;
+    private readonly entities;
     /**
-     * Bound to the `MaterialEntity` Symbol, so the DataLoader queries whichever
-     * material entity the consumer configured — the built-in `MaterialEntityClass`
-     * unless `materialEntity` was passed to `forRoot`/`forRootAsync`. Loading the
-     * built-in class outright would filter on its single-table-inheritance
-     * discriminator and resolve nothing for a custom entity.
+     * The configured entities, not the built-in classes: `__entity` decides which
+     * repository the DataLoader opens, so it has to follow whatever the consumer
+     * passed to `WMSBaseModuleOptions`. Loading a built-in class outright filters
+     * on its single-table-inheritance discriminator and resolves nothing for an
+     * override.
      */
-    constructor(materialEntity: new () => MaterialEntityClass);
+    constructor(entities: WmsEntities);
     material({ materialId }: ShipInventoryOrderItemEntityClass, { loaders }: LoaderType<MaterialEntityClass>): Promise<MaterialDto>;
     batch({ batchId }: ShipInventoryOrderItemEntityClass, { loaders }: LoaderType<BatchEntityClass>): Promise<BatchDto | null>;
     saleId({ batchId }: ShipInventoryOrderItemEntityClass, { loaders }: LoaderType<BatchEntityClass>): Promise<string | null>;
@@ -27,15 +27,15 @@ export declare class ShipInventoryOrderItemResolver {
     shippedQuantity({ id }: ShipInventoryOrderItemEntityClass, { loaders }: LoaderType<ShipInventoryOrderChangeEntityClass>): Promise<number>;
 }
 export declare class ShipInventoryOrderReferenceResolver {
-    private readonly materialEntity;
+    private readonly entities;
     /**
-     * Bound to the `MaterialEntity` Symbol, so the DataLoader queries whichever
-     * material entity the consumer configured — the built-in `MaterialEntityClass`
-     * unless `materialEntity` was passed to `forRoot`/`forRootAsync`. Loading the
-     * built-in class outright would filter on its single-table-inheritance
-     * discriminator and resolve nothing for a custom entity.
+     * The configured entities, not the built-in classes: `__entity` decides which
+     * repository the DataLoader opens, so it has to follow whatever the consumer
+     * passed to `WMSBaseModuleOptions`. Loading a built-in class outright filters
+     * on its single-table-inheritance discriminator and resolves nothing for an
+     * override.
      */
-    constructor(materialEntity: new () => MaterialEntityClass);
+    constructor(entities: WmsEntities);
     shippedQuantity({ orderId, serialId }: ShipInventoryOrderReferenceEntityClass, { loaders }: LoaderType<ShipInventoryOrderItemEntityClass>): Promise<number>;
     material({ materialId }: ShipInventoryOrderReferenceEntityClass, { loaders }: LoaderType<MaterialEntityClass>): Promise<MaterialDto>;
     batch({ batchId }: ShipInventoryOrderReferenceEntityClass, { loaders }: LoaderType<BatchEntityClass>): Promise<BatchDto | null>;