@rytass/wms-module-graphql 0.7.0 → 0.8.0

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

@@ -1,5 +1,4 @@
 import { __decorate, __param, __metadata } from 'tslib';
-import { Inject } from '@nestjs/common';
 import { ResolveField, ID, Parent, Context, Resolver } from '@nestjs/graphql';
 import '../dto/loader-type.dto.js';
 import { LoaderDto } from '../dto/loader.dto.js';
@@ -25,37 +24,29 @@ 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 { MaterialEntity, StockService, BatchEntityClass, BatchGroupEntityClass, LocationEntityClass, LoadersEntityClass } from '@rytass/wms-module-core';
+import { StockService, WmsEntities, BatchGroupEntityClass, 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;
-    materialEntity;
-    /**
-     * `materialEntity` is 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.
-     */
-    constructor(stockService, materialEntity) {
+    entities;
+    constructor(stockService, entities) {
         this.stockService = stockService;
-        this.materialEntity = materialEntity;
+        this.entities = entities;
     }
     async id(stock) {
         return this.stockService.generatedAggregateKey(stock);
     }
     async material({ materialId }, { loaders }) {
         return loaders.batchSingle.load({
-            __entity: this.materialEntity,
+            __entity: this.entities.material,
             __from: { id: materialId },
         });
     }
     async batch({ batchId }, { loaders }) {
         const { groupId } = await loaders.batchSingle.load({
-            __entity: BatchEntityClass,
+            __entity: this.entities.batch,
             __from: { id: batchId },
         });
         return loaders.batchSingle.load({
@@ -65,7 +56,7 @@ let AggregatedStockResolver = class AggregatedStockResolver {
     }
     async location({ locationId }, { loaders }) {
         return loaders.batchSingle.load({
-            __entity: LocationEntityClass,
+            __entity: this.entities.location,
             __from: { id: locationId },
         });
     }
@@ -117,8 +108,8 @@ __decorate([
 ], AggregatedStockResolver.prototype, "loader", null);
 AggregatedStockResolver = __decorate([
     Resolver(() => AggregatedStockDto),
-    __param(1, Inject(MaterialEntity)),
-    __metadata("design:paramtypes", [StockService, Function])
+    __metadata("design:paramtypes", [StockService,
+        WmsEntities])
 ], AggregatedStockResolver);
 
 export { AggregatedStockResolver };

package/lib/resolvers/change-log.resolver.d.ts

@@ -1,18 +1,18 @@
 import { MaterialDto } from '../dto';
-import { BatchEntityClass, LocationEntityClass, MaterialEntityClass, StockEntityClass } from '@rytass/wms-module-core';
+import { BatchEntityClass, LocationEntityClass, MaterialEntityClass, StockEntityClass, WmsEntities } 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 {
-    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 }: 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

@@ -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,37 @@ 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 { 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 +89,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/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,22 @@ 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 { 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 +50,7 @@ let LoaderResolver = class LoaderResolver {
     }
     location({ locationId }, { loaders }) {
         return loaders.batchSingle.load({
-            __entity: LocationEntityClass,
+            __entity: this.entities.location,
             __from: { id: locationId },
         });
     }
@@ -80,7 +89,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/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,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 { ReceiveInventoryOrderItemEntityClass, MaterialEntity, BatchEntityClass, BatchGroupEntityClass, LocationEntityClass, LoadersEntityClass, ReceiveInventoryOrderChangeEntityClass } from '@rytass/wms-module-core';
+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 +49,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 +70,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 +82,7 @@ let ReceiveInventoryOrderItemResolver = class ReceiveInventoryOrderItemResolver
         if (!locationId)
             return null;
         return loaders.batchSingle.load({
-            __entity: LocationEntityClass,
+            __entity: this.entities.location,
             __from: { id: locationId },
         });
     }
@@ -147,8 +146,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>;

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

@@ -1,5 +1,4 @@
 import { __decorate, __param, __metadata } from 'tslib';
-import { Inject } from '@nestjs/common';
 import { ResolveField, Parent, Context, Resolver, ID, Int } from '@nestjs/graphql';
 import '../dto/loader-type.dto.js';
 import { LoaderDto } from '../dto/loader.dto.js';
@@ -25,7 +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 { ShipInventoryOrderEntityClass, ShipInventoryOrderItemEntityClass, MaterialEntity, ShipInventoryOrderReferenceEntityClass, BatchEntityClass, BatchGroupEntityClass, LocationEntityClass, LoadersEntityClass, ShipInventoryOrderChangeEntityClass } from '@rytass/wms-module-core';
+import { ShipInventoryOrderEntityClass, ShipInventoryOrderItemEntityClass, WmsEntities, ShipInventoryOrderReferenceEntityClass, BatchGroupEntityClass, LoadersEntityClass, ShipInventoryOrderChangeEntityClass } from '@rytass/wms-module-core';
 import { BatchDto } from '../dto/batch.dto.js';
 import { LocationDto } from '../dto/location.dto.js';
 import { ShipInventoryOrderReferenceDto } from '../dto/ship-inventory-order-reference.dto.js';
@@ -65,20 +64,20 @@ ShipInventoryOrderResolver = __decorate([
     Resolver(() => ShipInventoryOrderDto)
 ], ShipInventoryOrderResolver);
 let ShipInventoryOrderItemResolver = class ShipInventoryOrderItemResolver {
-    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 },
         });
     }
@@ -86,7 +85,7 @@ let ShipInventoryOrderItemResolver = class ShipInventoryOrderItemResolver {
         if (!batchId)
             return null;
         const { groupId } = await loaders.batchSingle.load({
-            __entity: BatchEntityClass,
+            __entity: this.entities.batch,
             __from: { id: batchId },
         });
         return loaders.batchSingle.load({
@@ -98,7 +97,7 @@ let ShipInventoryOrderItemResolver = class ShipInventoryOrderItemResolver {
         if (!batchId)
             return null;
         const { groupId } = await loaders.batchSingle.load({
-            __entity: BatchEntityClass,
+            __entity: this.entities.batch,
             __from: { id: batchId },
         });
         return loaders.batchSingle
@@ -112,7 +111,7 @@ let ShipInventoryOrderItemResolver = class ShipInventoryOrderItemResolver {
         if (!batchId)
             return null;
         const { groupId } = await loaders.batchSingle.load({
-            __entity: BatchEntityClass,
+            __entity: this.entities.batch,
             __from: { id: batchId },
         });
         return loaders.batchSingle
@@ -126,7 +125,7 @@ let ShipInventoryOrderItemResolver = class ShipInventoryOrderItemResolver {
         if (!locationId)
             return null;
         return loaders.batchSingle.load({
-            __entity: LocationEntityClass,
+            __entity: this.entities.location,
             __from: { id: locationId },
         });
     }
@@ -207,20 +206,19 @@ __decorate([
 ], ShipInventoryOrderItemResolver.prototype, "shippedQuantity", null);
 ShipInventoryOrderItemResolver = __decorate([
     Resolver(() => ShipInventoryOrderItemDto),
-    __param(0, Inject(MaterialEntity)),
-    __metadata("design:paramtypes", [Function])
+    __metadata("design:paramtypes", [WmsEntities])
 ], ShipInventoryOrderItemResolver);
 let ShipInventoryOrderReferenceResolver = class ShipInventoryOrderReferenceResolver {
-    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;
     }
     async shippedQuantity({ orderId, serialId }, { loaders }) {
         const items = await loaders.batchMany.load({
@@ -236,7 +234,7 @@ let ShipInventoryOrderReferenceResolver = class ShipInventoryOrderReferenceResol
     }
     material({ materialId }, { loaders }) {
         return loaders.batchSingle.load({
-            __entity: this.materialEntity,
+            __entity: this.entities.material,
             __from: { id: materialId },
         });
     }
@@ -244,7 +242,7 @@ let ShipInventoryOrderReferenceResolver = class ShipInventoryOrderReferenceResol
         if (!batchId)
             return null;
         const { groupId } = await loaders.batchSingle.load({
-            __entity: BatchEntityClass,
+            __entity: this.entities.batch,
             __from: { id: batchId },
         });
         return loaders.batchSingle.load({
@@ -293,8 +291,7 @@ __decorate([
 ], ShipInventoryOrderReferenceResolver.prototype, "items", null);
 ShipInventoryOrderReferenceResolver = __decorate([
     Resolver(() => ShipInventoryOrderReferenceDto),
-    __param(0, Inject(MaterialEntity)),
-    __metadata("design:paramtypes", [Function])
+    __metadata("design:paramtypes", [WmsEntities])
 ], ShipInventoryOrderReferenceResolver);
 
 export { ShipInventoryOrderItemResolver, ShipInventoryOrderReferenceResolver, ShipInventoryOrderResolver };

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

@@ -1,18 +1,18 @@
 import { MaterialDto } from '../dto';
-import { BatchEntityClass, LocationEntityClass, MaterialEntityClass, StockEntityClass } from '@rytass/wms-module-core';
+import { BatchEntityClass, LocationEntityClass, MaterialEntityClass, StockEntityClass, WmsEntities } 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 StockResolver {
-    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 }: StockEntityClass, { loaders }: LoaderType<MaterialEntityClass>): Promise<MaterialDto>;
     location({ locationId }: StockEntityClass, { loaders }: LoaderType<LocationEntityClass>): Promise<LocationDto>;
     batch({ batchId }: StockEntityClass, { loaders }: LoaderType<BatchEntityClass>): Promise<BatchDto | null>;