@rytass/wms-module-graphql 0.6.1 → 0.8.0

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

@@ -24,26 +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, MaterialEntityClass, 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 {
+    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;
+    }
     material({ materialId }, { loaders }) {
         return loaders.batchSingle.load({
-            __entity: MaterialEntityClass,
+            __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({
@@ -77,7 +88,8 @@ __decorate([
     __metadata("design:returntype", Promise)
 ], ChangeLogResolver.prototype, "batch", null);
 ChangeLogResolver = __decorate([
-    Resolver(() => ChangeLogDto)
+    Resolver(() => ChangeLogDto),
+    __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,12 +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 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);
     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

@@ -24,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, MaterialEntityClass, 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';
 
@@ -49,9 +49,20 @@ ReceiveInventoryOrderResolver = __decorate([
     Resolver(() => ReceiveInventoryOrderDto)
 ], ReceiveInventoryOrderResolver);
 let ReceiveInventoryOrderItemResolver = class ReceiveInventoryOrderItemResolver {
+    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;
+    }
     material({ materialId }, { loaders }) {
         return loaders.batchSingle.load({
-            __entity: MaterialEntityClass,
+            __entity: this.entities.material,
             __from: { id: materialId },
         });
     }
@@ -59,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({
@@ -71,7 +82,7 @@ let ReceiveInventoryOrderItemResolver = class ReceiveInventoryOrderItemResolver
         if (!locationId)
             return null;
         return loaders.batchSingle.load({
-            __entity: LocationEntityClass,
+            __entity: this.entities.location,
             __from: { id: locationId },
         });
     }
@@ -134,7 +145,8 @@ __decorate([
     __metadata("design:returntype", Promise)
 ], ReceiveInventoryOrderItemResolver.prototype, "receivedQuantity", null);
 ReceiveInventoryOrderItemResolver = __decorate([
-    Resolver(() => ReceiveInventoryOrderItemDto)
+    Resolver(() => ReceiveInventoryOrderItemDto),
+    __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,6 +9,15 @@ export declare class ShipInventoryOrderResolver {
     references({ id }: ShipInventoryOrderEntityClass, { loaders }: LoaderType<ShipInventoryOrderReferenceEntityClass>): Promise<ShipInventoryOrderReferenceDto[]>;
 }
 export declare class ShipInventoryOrderItemResolver {
+    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);
     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>;
@@ -18,6 +27,15 @@ export declare class ShipInventoryOrderItemResolver {
     shippedQuantity({ id }: ShipInventoryOrderItemEntityClass, { loaders }: LoaderType<ShipInventoryOrderChangeEntityClass>): Promise<number>;
 }
 export declare class ShipInventoryOrderReferenceResolver {
+    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);
     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

@@ -24,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, ShipInventoryOrderReferenceEntityClass, MaterialEntityClass, 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';
@@ -64,9 +64,20 @@ ShipInventoryOrderResolver = __decorate([
     Resolver(() => ShipInventoryOrderDto)
 ], ShipInventoryOrderResolver);
 let ShipInventoryOrderItemResolver = class ShipInventoryOrderItemResolver {
+    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;
+    }
     material({ materialId }, { loaders }) {
         return loaders.batchSingle.load({
-            __entity: MaterialEntityClass,
+            __entity: this.entities.material,
             __from: { id: materialId },
         });
     }
@@ -74,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({
@@ -86,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
@@ -100,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
@@ -114,7 +125,7 @@ let ShipInventoryOrderItemResolver = class ShipInventoryOrderItemResolver {
         if (!locationId)
             return null;
         return loaders.batchSingle.load({
-            __entity: LocationEntityClass,
+            __entity: this.entities.location,
             __from: { id: locationId },
         });
     }
@@ -194,9 +205,21 @@ __decorate([
     __metadata("design:returntype", Promise)
 ], ShipInventoryOrderItemResolver.prototype, "shippedQuantity", null);
 ShipInventoryOrderItemResolver = __decorate([
-    Resolver(() => ShipInventoryOrderItemDto)
+    Resolver(() => ShipInventoryOrderItemDto),
+    __metadata("design:paramtypes", [WmsEntities])
 ], ShipInventoryOrderItemResolver);
 let ShipInventoryOrderReferenceResolver = class ShipInventoryOrderReferenceResolver {
+    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 shippedQuantity({ orderId, serialId }, { loaders }) {
         const items = await loaders.batchMany.load({
             __entity: ShipInventoryOrderItemEntityClass,
@@ -211,7 +234,7 @@ let ShipInventoryOrderReferenceResolver = class ShipInventoryOrderReferenceResol
     }
     material({ materialId }, { loaders }) {
         return loaders.batchSingle.load({
-            __entity: MaterialEntityClass,
+            __entity: this.entities.material,
             __from: { id: materialId },
         });
     }
@@ -219,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({
@@ -267,7 +290,8 @@ __decorate([
     __metadata("design:returntype", Promise)
 ], ShipInventoryOrderReferenceResolver.prototype, "items", null);
 ShipInventoryOrderReferenceResolver = __decorate([
-    Resolver(() => ShipInventoryOrderReferenceDto)
+    Resolver(() => ShipInventoryOrderReferenceDto),
+    __metadata("design:paramtypes", [WmsEntities])
 ], ShipInventoryOrderReferenceResolver);
 
 export { ShipInventoryOrderItemResolver, ShipInventoryOrderReferenceResolver, ShipInventoryOrderResolver };

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

@@ -1,9 +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 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);
     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>;

package/lib/resolvers/stock.resolver.js

@@ -24,26 +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, MaterialEntityClass, 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 StockResolver = class StockResolver {
+    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;
+    }
     material({ materialId }, { loaders }) {
         return loaders.batchSingle.load({
-            __entity: MaterialEntityClass,
+            __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({
@@ -77,7 +88,8 @@ __decorate([
     __metadata("design:returntype", Promise)
 ], StockResolver.prototype, "batch", null);
 StockResolver = __decorate([
-    Resolver(() => StockDto)
+    Resolver(() => StockDto),
+    __metadata("design:paramtypes", [WmsEntities])
 ], StockResolver);
 
 export { StockResolver };

package/lib/resolvers/transfer-order.resolver.d.ts

@@ -1,16 +1,34 @@
 import { TransferOrderDto } from '../dto/transfer-order.dto';
 import { TransferOrderItemDto } from '../dto/transfer-order-item.dto';
 import { type LoaderType } from '../helpers';
-import { BatchEntityClass, LoadersEntityClass, LocationEntityClass, MaterialEntityClass, TransferOrderChangeEntityClass, TransferOrderItemEntityClass } from '@rytass/wms-module-core';
+import { BatchEntityClass, LoadersEntityClass, LocationEntityClass, MaterialEntityClass, TransferOrderChangeEntityClass, TransferOrderItemEntityClass, WmsEntities } from '@rytass/wms-module-core';
 import { LoaderDto, MaterialDto } from '../dto';
 import { BatchDto } from '../dto/batch.dto';
 import { LocationDto } from '../dto/location.dto';
 export declare class TransferOrderResolver {
+    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);
     items({ id }: TransferOrderDto, { loaders }: LoaderType<TransferOrderItemEntityClass>): Promise<TransferOrderItemDto[]>;
     targetLocation({ id }: TransferOrderDto, { loaders }: LoaderType<TransferOrderItemEntityClass>, locationLoader: LoaderType<LocationEntityClass>): Promise<LocationDto | null>;
     targetLoader({ id }: TransferOrderDto, { loaders }: LoaderType<TransferOrderItemEntityClass>, loaderLoader: LoaderType<LoadersEntityClass>): Promise<LoaderDto | null>;
 }
 export declare class TransferOrderItemResolver {
+    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);
     material({ materialId }: TransferOrderItemEntityClass, { loaders }: LoaderType<MaterialEntityClass>): Promise<MaterialDto>;
     batch({ batchId }: TransferOrderItemEntityClass, { loaders }: LoaderType<BatchEntityClass>): Promise<BatchDto | null>;
     location({ locationId }: TransferOrderItemEntityClass, { loaders }: LoaderType<LocationEntityClass>): Promise<LocationDto | null>;

package/lib/resolvers/transfer-order.resolver.js

@@ -2,7 +2,7 @@ import { __decorate, __param, __metadata } from 'tslib';
 import { ResolveField, Parent, Context, Resolver, ID, Int } from '@nestjs/graphql';
 import { TransferOrderDto } from '../dto/transfer-order.dto.js';
 import { TransferOrderItemDto } from '../dto/transfer-order-item.dto.js';
-import { TransferOrderItemEntityClass, LocationEntityClass, LoadersEntityClass, MaterialEntityClass, BatchEntityClass, BatchGroupEntityClass, TransferOrderChangeEntityClass } from '@rytass/wms-module-core';
+import { WmsEntities, TransferOrderItemEntityClass, LoadersEntityClass, BatchGroupEntityClass, TransferOrderChangeEntityClass } from '@rytass/wms-module-core';
 import '../dto/loader-type.dto.js';
 import { LoaderDto } from '../dto/loader.dto.js';
 import { MaterialDto } from '../dto/material.dto.js';
@@ -29,6 +29,17 @@ import { BatchDto } from '../dto/batch.dto.js';
 import { LocationDto } from '../dto/location.dto.js';
 
 let TransferOrderResolver = class TransferOrderResolver {
+    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;
+    }
     items({ id }, { loaders }) {
         return loaders.batchMany.load({
             __entity: TransferOrderItemEntityClass,
@@ -43,7 +54,7 @@ let TransferOrderResolver = class TransferOrderResolver {
         if (!item?.targetLocationId)
             return null;
         return locationLoader.loaders.batchSingle.load({
-            __entity: LocationEntityClass,
+            __entity: this.entities.location,
             __from: { id: item.targetLocationId },
         });
     }
@@ -87,12 +98,24 @@ __decorate([
     __metadata("design:returntype", Promise)
 ], TransferOrderResolver.prototype, "targetLoader", null);
 TransferOrderResolver = __decorate([
-    Resolver(() => TransferOrderDto)
+    Resolver(() => TransferOrderDto),
+    __metadata("design:paramtypes", [WmsEntities])
 ], TransferOrderResolver);
 let TransferOrderItemResolver = class TransferOrderItemResolver {
+    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;
+    }
     material({ materialId }, { loaders }) {
         return loaders.batchSingle.load({
-            __entity: MaterialEntityClass,
+            __entity: this.entities.material,
             __from: { id: materialId },
         });
     }
@@ -100,7 +123,7 @@ let TransferOrderItemResolver = class TransferOrderItemResolver {
         if (!batchId)
             return null;
         const { groupId } = await loaders.batchSingle.load({
-            __entity: BatchEntityClass,
+            __entity: this.entities.batch,
             __from: { id: batchId },
         });
         return loaders.batchSingle.load({
@@ -112,7 +135,7 @@ let TransferOrderItemResolver = class TransferOrderItemResolver {
         if (!locationId)
             return null;
         return loaders.batchSingle.load({
-            __entity: LocationEntityClass,
+            __entity: this.entities.location,
             __from: { id: locationId },
         });
     }
@@ -129,7 +152,7 @@ let TransferOrderItemResolver = class TransferOrderItemResolver {
             return null;
         return loaders.batchSingle
             .load({
-            __entity: BatchEntityClass,
+            __entity: this.entities.batch,
             __from: { id: batchId },
         })
             .then((batch) => batch.saleId);
@@ -139,7 +162,7 @@ let TransferOrderItemResolver = class TransferOrderItemResolver {
             return null;
         return loaders.batchSingle
             .load({
-            __entity: BatchEntityClass,
+            __entity: this.entities.batch,
             __from: { id: batchId },
         })
             .then((batch) => batch.saleSerialId);
@@ -212,7 +235,8 @@ __decorate([
     __metadata("design:returntype", Promise)
 ], TransferOrderItemResolver.prototype, "transferredQuantity", null);
 TransferOrderItemResolver = __decorate([
-    Resolver(() => TransferOrderItemDto)
+    Resolver(() => TransferOrderItemDto),
+    __metadata("design:paramtypes", [WmsEntities])
 ], TransferOrderItemResolver);
 
 export { TransferOrderItemResolver, TransferOrderResolver };