@rytass/wms-module-graphql 0.6.1 → 0.7.0

package/README.md

@@ -62,6 +62,22 @@ You register a **single** `GraphQLModule.forRootAsync(...)` of your own, mix you
 
 `WmsModuleGraphqlModule` internally wires `WmsModuleCoreModule.forRootAsync` so you do not need to import the core module separately when using this package.
 
+## Custom material entity
+
+`materialEntity` is an ordinary `WMSBaseModuleOptions` field that reaches all the way down, so a downstream project's own item master can *be* the WMS material master — every resolver's `material` DataLoader resolves against it too:
+
+```ts
+WmsModuleGraphqlModule.forRootAsync({
+  // a @ChildEntity() of MaterialEntityClass
+  useFactory: async () => ({ materialEntity: ItemMasterEntity }),
+  defaultLoaderSerialId: 'DEFAULT',
+  defaultLoaderTypeKey: 'DEFAULT',
+  defaultLocationKey: 'DEFAULT',
+});
+```
+
+Register the entity with TypeORM yourself (`TypeOrmModule.forFeature([ItemMasterEntity])`); the module checks at startup and refuses to boot if it is missing. Requires `@rytass/wms-base-nestjs-module` >= 0.3.0. See [`@rytass/wms-module-core`'s custom-entities guide](https://github.com/Rytass/WMS-Module/blob/main/libs/core/docs/custom-entities.md) for the single-table-inheritance caveats and which other entity options are not honoured yet.
+
 ## Authorization
 
 Every WMS root `@Query` / `@Mutation` is annotated with `@WmsOperation({ resource, action })` — a **host-neutral** permission requirement enforced by the library's own route-level `WmsAuthGuard`, which delegates the allow/deny decision to an `authChecker` **you** supply. The library never imports your auth system; you map WMS's `resource`/`action` onto whatever you use (Casbin, RBAC, JWT scopes…).

package/docs/api-reference.md

@@ -311,6 +311,12 @@ static forRootAsync(
   //     defaultLocationKey: string     — 預設儲存位置 key
   // + WmsAuthModuleOptions:
   //     authChecker?: WmsAuthChecker   — 選填；resolver 授權委派函式（見 Authorization）
+  //
+  // since 0.7.0（需 wms-base-nestjs-module >= 0.3.0）：
+  //   WMSBaseModuleOptions.materialEntity 會一路作用到所有 resolver 的
+  //   material DataLoader。傳入 MaterialEntityClass 的 @ChildEntity() 即可，
+  //   forRoot 與 async factory 皆支援；entity 需自行註冊給 TypeORM。
+  //   詳見 core 的 docs/custom-entities.md。
 ): DynamicModule
 ```
 

package/index.cjs.js

@@ -3283,9 +3283,20 @@ Batches = tslib.__decorate([
 ], Batches);
 
 let StockResolver = class StockResolver {
+    materialEntity;
+    /**
+     * 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(materialEntity) {
+        this.materialEntity = materialEntity;
+    }
     material({ materialId }, { loaders }) {
         return loaders.batchSingle.load({
-            __entity: wmsModuleCore.MaterialEntityClass,
+            __entity: this.materialEntity,
             __from: { id: materialId },
         });
     }
@@ -3331,7 +3342,9 @@ tslib.__decorate([
     tslib.__metadata("design:returntype", Promise)
 ], StockResolver.prototype, "batch", null);
 StockResolver = tslib.__decorate([
-    graphql.Resolver(() => StockDto)
+    graphql.Resolver(() => StockDto),
+    tslib.__param(0, common.Inject(wmsModuleCore.MaterialEntity)),
+    tslib.__metadata("design:paramtypes", [Function])
 ], StockResolver);
 
 var MapRangeType;
@@ -3905,15 +3918,25 @@ UnitQuery = tslib.__decorate([
 
 let AggregatedStockResolver = class AggregatedStockResolver {
     stockService;
-    constructor(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) {
         this.stockService = stockService;
+        this.materialEntity = materialEntity;
     }
     async id(stock) {
         return this.stockService.generatedAggregateKey(stock);
     }
     async material({ materialId }, { loaders }) {
         return loaders.batchSingle.load({
-            __entity: wmsModuleCore.MaterialEntityClass,
+            __entity: this.materialEntity,
             __from: { id: materialId },
         });
     }
@@ -3981,7 +4004,8 @@ tslib.__decorate([
 ], AggregatedStockResolver.prototype, "loader", null);
 AggregatedStockResolver = tslib.__decorate([
     graphql.Resolver(() => AggregatedStockDto),
-    tslib.__metadata("design:paramtypes", [wmsModuleCore.StockService])
+    tslib.__param(1, common.Inject(wmsModuleCore.MaterialEntity)),
+    tslib.__metadata("design:paramtypes", [wmsModuleCore.StockService, Function])
 ], AggregatedStockResolver);
 
 let CreateTransferOrderItemArgs = class CreateTransferOrderItemArgs {
@@ -4367,9 +4391,20 @@ TransferOrderResolver = tslib.__decorate([
     graphql.Resolver(() => TransferOrderDto)
 ], TransferOrderResolver);
 let TransferOrderItemResolver = class TransferOrderItemResolver {
+    materialEntity;
+    /**
+     * 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(materialEntity) {
+        this.materialEntity = materialEntity;
+    }
     material({ materialId }, { loaders }) {
         return loaders.batchSingle.load({
-            __entity: wmsModuleCore.MaterialEntityClass,
+            __entity: this.materialEntity,
             __from: { id: materialId },
         });
     }
@@ -4489,7 +4524,9 @@ tslib.__decorate([
     tslib.__metadata("design:returntype", Promise)
 ], TransferOrderItemResolver.prototype, "transferredQuantity", null);
 TransferOrderItemResolver = tslib.__decorate([
-    graphql.Resolver(() => TransferOrderItemDto)
+    graphql.Resolver(() => TransferOrderItemDto),
+    tslib.__param(0, common.Inject(wmsModuleCore.MaterialEntity)),
+    tslib.__metadata("design:paramtypes", [Function])
 ], TransferOrderItemResolver);
 
 let CreateHoldInventoryOrderItemArgs = class CreateHoldInventoryOrderItemArgs {
@@ -4785,9 +4822,20 @@ BatchQuery = tslib.__decorate([
 ], BatchQuery);
 
 let ChangeLogResolver = class ChangeLogResolver {
+    materialEntity;
+    /**
+     * 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(materialEntity) {
+        this.materialEntity = materialEntity;
+    }
     material({ materialId }, { loaders }) {
         return loaders.batchSingle.load({
-            __entity: wmsModuleCore.MaterialEntityClass,
+            __entity: this.materialEntity,
             __from: { id: materialId },
         });
     }
@@ -4833,7 +4881,9 @@ tslib.__decorate([
     tslib.__metadata("design:returntype", Promise)
 ], ChangeLogResolver.prototype, "batch", null);
 ChangeLogResolver = tslib.__decorate([
-    graphql.Resolver(() => ChangeLogDto)
+    graphql.Resolver(() => ChangeLogDto),
+    tslib.__param(0, common.Inject(wmsModuleCore.MaterialEntity)),
+    tslib.__metadata("design:paramtypes", [Function])
 ], ChangeLogResolver);
 
 let ReceiveInventoryOrderResolver = class ReceiveInventoryOrderResolver {
@@ -4857,9 +4907,20 @@ ReceiveInventoryOrderResolver = tslib.__decorate([
     graphql.Resolver(() => ReceiveInventoryOrderDto)
 ], ReceiveInventoryOrderResolver);
 let ReceiveInventoryOrderItemResolver = class ReceiveInventoryOrderItemResolver {
+    materialEntity;
+    /**
+     * 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(materialEntity) {
+        this.materialEntity = materialEntity;
+    }
     material({ materialId }, { loaders }) {
         return loaders.batchSingle.load({
-            __entity: wmsModuleCore.MaterialEntityClass,
+            __entity: this.materialEntity,
             __from: { id: materialId },
         });
     }
@@ -4942,7 +5003,9 @@ tslib.__decorate([
     tslib.__metadata("design:returntype", Promise)
 ], ReceiveInventoryOrderItemResolver.prototype, "receivedQuantity", null);
 ReceiveInventoryOrderItemResolver = tslib.__decorate([
-    graphql.Resolver(() => ReceiveInventoryOrderItemDto)
+    graphql.Resolver(() => ReceiveInventoryOrderItemDto),
+    tslib.__param(0, common.Inject(wmsModuleCore.MaterialEntity)),
+    tslib.__metadata("design:paramtypes", [Function])
 ], ReceiveInventoryOrderItemResolver);
 
 let FindAllocateInventoryOrderArgs = class FindAllocateInventoryOrderArgs extends PaginationArgs {
@@ -5279,9 +5342,20 @@ ShipInventoryOrderResolver = tslib.__decorate([
     graphql.Resolver(() => ShipInventoryOrderDto)
 ], ShipInventoryOrderResolver);
 let ShipInventoryOrderItemResolver = class ShipInventoryOrderItemResolver {
+    materialEntity;
+    /**
+     * 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(materialEntity) {
+        this.materialEntity = materialEntity;
+    }
     material({ materialId }, { loaders }) {
         return loaders.batchSingle.load({
-            __entity: wmsModuleCore.MaterialEntityClass,
+            __entity: this.materialEntity,
             __from: { id: materialId },
         });
     }
@@ -5409,9 +5483,22 @@ tslib.__decorate([
     tslib.__metadata("design:returntype", Promise)
 ], ShipInventoryOrderItemResolver.prototype, "shippedQuantity", null);
 ShipInventoryOrderItemResolver = tslib.__decorate([
-    graphql.Resolver(() => ShipInventoryOrderItemDto)
+    graphql.Resolver(() => ShipInventoryOrderItemDto),
+    tslib.__param(0, common.Inject(wmsModuleCore.MaterialEntity)),
+    tslib.__metadata("design:paramtypes", [Function])
 ], ShipInventoryOrderItemResolver);
 let ShipInventoryOrderReferenceResolver = class ShipInventoryOrderReferenceResolver {
+    materialEntity;
+    /**
+     * 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(materialEntity) {
+        this.materialEntity = materialEntity;
+    }
     async shippedQuantity({ orderId, serialId }, { loaders }) {
         const items = await loaders.batchMany.load({
             __entity: wmsModuleCore.ShipInventoryOrderItemEntityClass,
@@ -5426,7 +5513,7 @@ let ShipInventoryOrderReferenceResolver = class ShipInventoryOrderReferenceResol
     }
     material({ materialId }, { loaders }) {
         return loaders.batchSingle.load({
-            __entity: wmsModuleCore.MaterialEntityClass,
+            __entity: this.materialEntity,
             __from: { id: materialId },
         });
     }
@@ -5482,7 +5569,9 @@ tslib.__decorate([
     tslib.__metadata("design:returntype", Promise)
 ], ShipInventoryOrderReferenceResolver.prototype, "items", null);
 ShipInventoryOrderReferenceResolver = tslib.__decorate([
-    graphql.Resolver(() => ShipInventoryOrderReferenceDto)
+    graphql.Resolver(() => ShipInventoryOrderReferenceDto),
+    tslib.__param(0, common.Inject(wmsModuleCore.MaterialEntity)),
+    tslib.__metadata("design:paramtypes", [Function])
 ], ShipInventoryOrderReferenceResolver);
 
 let FindSaleOrderArgs = class FindSaleOrderArgs extends PaginationArgs {

package/lib/helpers/loader.service.d.ts

@@ -1,7 +1,13 @@
-import { DataSource, FindOptionsWhere, ObjectLiteral, SelectQueryBuilder } from 'typeorm';
+import { DataSource, EntityTarget, FindOptionsWhere, ObjectLiteral, SelectQueryBuilder } from 'typeorm';
 import DataLoader from 'dataloader';
 export interface LoaderOptions<K> {
-    __entity: ObjectLiteral;
+    /**
+     * Widened from `ObjectLiteral` so a resolver can pass the entity it had
+     * injected from the `MaterialEntity` / `…Entity` Symbols — those are typed as
+     * `EntityTarget`, which is also exactly what `core()` hands to
+     * `getRepository()`.
+     */
+    __entity: EntityTarget<ObjectLiteral>;
     __from: FindOptionsWhere<K>;
     __conditions?: (qb: SelectQueryBuilder<ObjectLiteral>) => SelectQueryBuilder<ObjectLiteral>;
     __seed?: string;

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

@@ -5,7 +5,16 @@ import { BatchDto } from '../dto/batch.dto';
 import { LocationDto } from '../dto/location.dto';
 export declare class AggregatedStockResolver {
     private readonly stockService;
-    constructor(stockService: StockService);
+    private readonly 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: StockService, materialEntity: new () => MaterialEntityClass);
     id(stock: AggregatedStockDto): Promise<string>;
     material({ materialId }: AggregatedStockDto, { loaders }: LoaderType<MaterialEntityClass>): Promise<MaterialDto>;
     batch({ batchId }: AggregatedStockDto, { loaders }: LoaderType<BatchEntityClass>): Promise<BatchDto>;

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

@@ -1,4 +1,5 @@
 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';
@@ -24,21 +25,31 @@ import '../dto/scrape-order.dto.js';
 import '../dto/scrape-order-item.dto.js';
 import '../dto/quality-inspection-order.dto.js';
 import '../dto/quality-inspection-order-item.dto.js';
-import { StockService, MaterialEntityClass, BatchEntityClass, BatchGroupEntityClass, LocationEntityClass, LoadersEntityClass } from '@rytass/wms-module-core';
+import { MaterialEntity, StockService, BatchEntityClass, BatchGroupEntityClass, LocationEntityClass, LoadersEntityClass } from '@rytass/wms-module-core';
 import { BatchDto } from '../dto/batch.dto.js';
 import { LocationDto } from '../dto/location.dto.js';
 
 let AggregatedStockResolver = class AggregatedStockResolver {
     stockService;
-    constructor(stockService) {
+    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) {
         this.stockService = stockService;
+        this.materialEntity = materialEntity;
     }
     async id(stock) {
         return this.stockService.generatedAggregateKey(stock);
     }
     async material({ materialId }, { loaders }) {
         return loaders.batchSingle.load({
-            __entity: MaterialEntityClass,
+            __entity: this.materialEntity,
             __from: { id: materialId },
         });
     }
@@ -106,7 +117,8 @@ __decorate([
 ], AggregatedStockResolver.prototype, "loader", null);
 AggregatedStockResolver = __decorate([
     Resolver(() => AggregatedStockDto),
-    __metadata("design:paramtypes", [StockService])
+    __param(1, Inject(MaterialEntity)),
+    __metadata("design:paramtypes", [StockService, Function])
 ], AggregatedStockResolver);
 
 export { AggregatedStockResolver };

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

@@ -4,6 +4,15 @@ import { type LoaderType } from '../helpers';
 import { LocationDto } from '../dto/location.dto';
 import { BatchDto } from '../dto/batch.dto';
 export declare class ChangeLogResolver {
+    private readonly materialEntity;
+    /**
+     * 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(materialEntity: new () => MaterialEntityClass);
     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,4 +1,5 @@
 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';
@@ -24,14 +25,25 @@ 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, MaterialEntity, LocationEntityClass, BatchEntityClass, BatchGroupEntityClass } from '@rytass/wms-module-core';
 import { LocationDto } from '../dto/location.dto.js';
 import { BatchDto } from '../dto/batch.dto.js';
 
 let ChangeLogResolver = class ChangeLogResolver {
+    materialEntity;
+    /**
+     * 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(materialEntity) {
+        this.materialEntity = materialEntity;
+    }
     material({ materialId }, { loaders }) {
         return loaders.batchSingle.load({
-            __entity: MaterialEntityClass,
+            __entity: this.materialEntity,
             __from: { id: materialId },
         });
     }
@@ -77,7 +89,9 @@ __decorate([
     __metadata("design:returntype", Promise)
 ], ChangeLogResolver.prototype, "batch", null);
 ChangeLogResolver = __decorate([
-    Resolver(() => ChangeLogDto)
+    Resolver(() => ChangeLogDto),
+    __param(0, Inject(MaterialEntity)),
+    __metadata("design:paramtypes", [Function])
 ], ChangeLogResolver);
 
 export { ChangeLogResolver };

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

@@ -7,6 +7,15 @@ export declare class ReceiveInventoryOrderResolver {
     items({ id }: ReceiveInventoryOrderDto, { loaders }: LoaderType<ReceiveInventoryOrderItemEntityClass>): Promise<ReceiveInventoryOrderItemDto[]>;
 }
 export declare class ReceiveInventoryOrderItemResolver {
+    private readonly materialEntity;
+    /**
+     * 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(materialEntity: new () => MaterialEntityClass);
     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,4 +1,5 @@
 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';
@@ -24,7 +25,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, MaterialEntity, BatchEntityClass, BatchGroupEntityClass, LocationEntityClass, LoadersEntityClass, ReceiveInventoryOrderChangeEntityClass } from '@rytass/wms-module-core';
 import { BatchDto } from '../dto/batch.dto.js';
 import { LocationDto } from '../dto/location.dto.js';
 
@@ -49,9 +50,20 @@ ReceiveInventoryOrderResolver = __decorate([
     Resolver(() => ReceiveInventoryOrderDto)
 ], ReceiveInventoryOrderResolver);
 let ReceiveInventoryOrderItemResolver = class ReceiveInventoryOrderItemResolver {
+    materialEntity;
+    /**
+     * 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(materialEntity) {
+        this.materialEntity = materialEntity;
+    }
     material({ materialId }, { loaders }) {
         return loaders.batchSingle.load({
-            __entity: MaterialEntityClass,
+            __entity: this.materialEntity,
             __from: { id: materialId },
         });
     }
@@ -134,7 +146,9 @@ __decorate([
     __metadata("design:returntype", Promise)
 ], ReceiveInventoryOrderItemResolver.prototype, "receivedQuantity", null);
 ReceiveInventoryOrderItemResolver = __decorate([
-    Resolver(() => ReceiveInventoryOrderItemDto)
+    Resolver(() => ReceiveInventoryOrderItemDto),
+    __param(0, Inject(MaterialEntity)),
+    __metadata("design:paramtypes", [Function])
 ], ReceiveInventoryOrderItemResolver);
 
 export { ReceiveInventoryOrderItemResolver, ReceiveInventoryOrderResolver };

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

@@ -9,6 +9,15 @@ export declare class ShipInventoryOrderResolver {
     references({ id }: ShipInventoryOrderEntityClass, { loaders }: LoaderType<ShipInventoryOrderReferenceEntityClass>): Promise<ShipInventoryOrderReferenceDto[]>;
 }
 export declare class ShipInventoryOrderItemResolver {
+    private readonly materialEntity;
+    /**
+     * 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(materialEntity: new () => MaterialEntityClass);
     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 materialEntity;
+    /**
+     * 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(materialEntity: new () => MaterialEntityClass);
     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,4 +1,5 @@
 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';
@@ -24,7 +25,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, MaterialEntity, ShipInventoryOrderReferenceEntityClass, BatchEntityClass, BatchGroupEntityClass, LocationEntityClass, 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 +65,20 @@ ShipInventoryOrderResolver = __decorate([
     Resolver(() => ShipInventoryOrderDto)
 ], ShipInventoryOrderResolver);
 let ShipInventoryOrderItemResolver = class ShipInventoryOrderItemResolver {
+    materialEntity;
+    /**
+     * 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(materialEntity) {
+        this.materialEntity = materialEntity;
+    }
     material({ materialId }, { loaders }) {
         return loaders.batchSingle.load({
-            __entity: MaterialEntityClass,
+            __entity: this.materialEntity,
             __from: { id: materialId },
         });
     }
@@ -194,9 +206,22 @@ __decorate([
     __metadata("design:returntype", Promise)
 ], ShipInventoryOrderItemResolver.prototype, "shippedQuantity", null);
 ShipInventoryOrderItemResolver = __decorate([
-    Resolver(() => ShipInventoryOrderItemDto)
+    Resolver(() => ShipInventoryOrderItemDto),
+    __param(0, Inject(MaterialEntity)),
+    __metadata("design:paramtypes", [Function])
 ], ShipInventoryOrderItemResolver);
 let ShipInventoryOrderReferenceResolver = class ShipInventoryOrderReferenceResolver {
+    materialEntity;
+    /**
+     * 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(materialEntity) {
+        this.materialEntity = materialEntity;
+    }
     async shippedQuantity({ orderId, serialId }, { loaders }) {
         const items = await loaders.batchMany.load({
             __entity: ShipInventoryOrderItemEntityClass,
@@ -211,7 +236,7 @@ let ShipInventoryOrderReferenceResolver = class ShipInventoryOrderReferenceResol
     }
     material({ materialId }, { loaders }) {
         return loaders.batchSingle.load({
-            __entity: MaterialEntityClass,
+            __entity: this.materialEntity,
             __from: { id: materialId },
         });
     }
@@ -267,7 +292,9 @@ __decorate([
     __metadata("design:returntype", Promise)
 ], ShipInventoryOrderReferenceResolver.prototype, "items", null);
 ShipInventoryOrderReferenceResolver = __decorate([
-    Resolver(() => ShipInventoryOrderReferenceDto)
+    Resolver(() => ShipInventoryOrderReferenceDto),
+    __param(0, Inject(MaterialEntity)),
+    __metadata("design:paramtypes", [Function])
 ], ShipInventoryOrderReferenceResolver);
 
 export { ShipInventoryOrderItemResolver, ShipInventoryOrderReferenceResolver, ShipInventoryOrderResolver };

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

@@ -4,6 +4,15 @@ import { type LoaderType } from '../helpers';
 import { LocationDto } from '../dto/location.dto';
 import { BatchDto } from '../dto/batch.dto';
 export declare class StockResolver {
+    private readonly materialEntity;
+    /**
+     * 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(materialEntity: new () => MaterialEntityClass);
     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

@@ -1,4 +1,5 @@
 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';
@@ -24,14 +25,25 @@ 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, MaterialEntity, LocationEntityClass, BatchEntityClass, BatchGroupEntityClass } from '@rytass/wms-module-core';
 import { LocationDto } from '../dto/location.dto.js';
 import { BatchDto } from '../dto/batch.dto.js';
 
 let StockResolver = class StockResolver {
+    materialEntity;
+    /**
+     * 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(materialEntity) {
+        this.materialEntity = materialEntity;
+    }
     material({ materialId }, { loaders }) {
         return loaders.batchSingle.load({
-            __entity: MaterialEntityClass,
+            __entity: this.materialEntity,
             __from: { id: materialId },
         });
     }
@@ -77,7 +89,9 @@ __decorate([
     __metadata("design:returntype", Promise)
 ], StockResolver.prototype, "batch", null);
 StockResolver = __decorate([
-    Resolver(() => StockDto)
+    Resolver(() => StockDto),
+    __param(0, Inject(MaterialEntity)),
+    __metadata("design:paramtypes", [Function])
 ], StockResolver);
 
 export { StockResolver };

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

@@ -11,6 +11,15 @@ export declare class TransferOrderResolver {
     targetLoader({ id }: TransferOrderDto, { loaders }: LoaderType<TransferOrderItemEntityClass>, loaderLoader: LoaderType<LoadersEntityClass>): Promise<LoaderDto | null>;
 }
 export declare class TransferOrderItemResolver {
+    private readonly materialEntity;
+    /**
+     * 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(materialEntity: new () => MaterialEntityClass);
     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

@@ -1,8 +1,9 @@
 import { __decorate, __param, __metadata } from 'tslib';
+import { Inject } from '@nestjs/common';
 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 { TransferOrderItemEntityClass, MaterialEntity, LocationEntityClass, LoadersEntityClass, BatchEntityClass, 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';
@@ -90,9 +91,20 @@ TransferOrderResolver = __decorate([
     Resolver(() => TransferOrderDto)
 ], TransferOrderResolver);
 let TransferOrderItemResolver = class TransferOrderItemResolver {
+    materialEntity;
+    /**
+     * 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(materialEntity) {
+        this.materialEntity = materialEntity;
+    }
     material({ materialId }, { loaders }) {
         return loaders.batchSingle.load({
-            __entity: MaterialEntityClass,
+            __entity: this.materialEntity,
             __from: { id: materialId },
         });
     }
@@ -212,7 +224,9 @@ __decorate([
     __metadata("design:returntype", Promise)
 ], TransferOrderItemResolver.prototype, "transferredQuantity", null);
 TransferOrderItemResolver = __decorate([
-    Resolver(() => TransferOrderItemDto)
+    Resolver(() => TransferOrderItemDto),
+    __param(0, Inject(MaterialEntity)),
+    __metadata("design:paramtypes", [Function])
 ], TransferOrderItemResolver);
 
 export { TransferOrderItemResolver, TransferOrderResolver };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rytass/wms-module-graphql",
-  "version": "0.6.1",
+  "version": "0.7.0",
   "description": "Rytass WMS Module — GraphQL schema, resolvers and DTOs for warehouse management",
   "keywords": [
     "rytass",
@@ -57,7 +57,7 @@
     "@nestjs/apollo": ">=13.0.0 <13.2.0",
     "@nestjs/common": "^11.0.0",
     "@nestjs/graphql": "^13.0.0",
-    "@rytass/wms-module-core": "^0.3.1",
+    "@rytass/wms-module-core": "^0.4.0",
     "graphql": "^16.0.0",
     "reflect-metadata": "^0.1.13 || ^0.2.0",
     "rxjs": "^7.8.0",