@rytass/wms-module-graphql 0.6.0 → 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

@@ -55,6 +55,65 @@ exports.LoaderService = class LoaderService {
         const fields = ___default.default(Object.keys(__from)).sort();
         return `${__hash}_${fields.map((field) => data[field]).join('_')}`;
     }
+    /**
+     * resolve a `__from` property name to the physical column it is stored in.
+     *
+     * TypeORM's `FindOptionsWhere` only accepts real column properties. A
+     * `@RelationId()` property — e.g. `LocationEntityClass.parentId`, which mirrors
+     * the `parent` tree relation — is virtual and is rejected with
+     * `EntityPropertyNotFoundError`, even though it is backed by the relation's
+     * join column. Map those back to their join column so they stay batchable.
+     * @param EntityMetadata
+     * @param string
+     * @returns string | null
+     */
+    resolveColumnName(metadata, propertyName) {
+        const column = metadata.findColumnWithPropertyName(propertyName);
+        if (column)
+            return column.databaseName;
+        const relationId = metadata.relationIds.find((candidate) => candidate.propertyName === propertyName);
+        const joinColumns = relationId?.relation.joinColumns ?? [];
+        return joinColumns.length === 1 ? joinColumns[0].databaseName : null;
+    }
+    /**
+     * build the where clause for `__from` keys that TypeORM's find options cannot
+     * express (see {@link resolveColumnName}), by addressing the columns directly.
+     * @param SelectQueryBuilder
+     * @param EntityMetadata
+     * @param LoaderOptions[]
+     * @param (keyof T)[]
+     */
+    applyColumnWhere(qb, metadata, options, primaryKeys) {
+        const columns = primaryKeys.map((primaryKey) => {
+            const columnName = this.resolveColumnName(metadata, String(primaryKey));
+            if (!columnName)
+                throw new Error(`Loader cannot resolve property "${String(primaryKey)}" to a column of "${metadata.name}".`);
+            return {
+                primaryKey,
+                column: `entity.${this.dataSource.driver.escape(columnName)}`,
+            };
+        });
+        if (columns.length === 1) {
+            const [{ primaryKey, column }] = columns;
+            qb.andWhere(`${column} IN (:...wmsLoaderValues)`, {
+                wmsLoaderValues: options.map(({ __from }) => __from[primaryKey]),
+            });
+            return;
+        }
+        qb.andWhere(new typeorm.Brackets((where) => {
+            options.forEach(({ __from }, optionIndex) => {
+                const parameters = {};
+                const predicate = columns
+                    .map(({ primaryKey, column }, columnIndex) => {
+                    const parameter = `wmsLoaderValue_${optionIndex}_${columnIndex}`;
+                    parameters[parameter] = __from[primaryKey];
+                    return `${column} = :${parameter}`;
+                })
+                    .join(' AND ');
+                where.orWhere(`(${predicate})`, parameters);
+            });
+        }));
+    }
     /**
      * query data by collecting primary keys from options with same `__entity`
      * @param LoaderOptions[]
@@ -65,7 +124,10 @@ exports.LoaderService = class LoaderService {
         const repo = this.dataSource.getRepository(__entity);
         let qb = repo.createQueryBuilder('entity');
         const primaryKeys = Object.keys(__from);
-        if (primaryKeys.length > 1)
+        const hasVirtualKey = primaryKeys.some((primaryKey) => !repo.metadata.findColumnWithPropertyName(String(primaryKey)));
+        if (hasVirtualKey)
+            this.applyColumnWhere(qb, repo.metadata, options, primaryKeys);
+        else if (primaryKeys.length > 1)
             qb.setFindOptions({ where: options.map(({ __from }) => __from) });
         else {
             const [primaryKey] = primaryKeys;
@@ -3221,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 },
         });
     }
@@ -3269,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;
@@ -3611,8 +3686,21 @@ let LocationResolver = class LocationResolver {
             __from: { id: parentId },
         });
     }
-    children({ children }) {
-        return children;
+    /**
+     * `children` must never be read off the parent entity: only
+     * `LocationQuery.location` and `LocationService.findMany` eager-load the tree
+     * relation. Every other producer of a `LocationDto` (stock/loader/change-log/
+     * transfer/ship/receive/warehouse-map resolvers, the `parent` field above and
+     * the create/update mutations) hands back an entity whose `children` is
+     * `undefined`, which breaks the non-nullable list. Always resolve through the
+     * request-scoped loader instead.
+     */
+    children({ id }, { loaders }) {
+        return loaders.batchMany.load({
+            __entity: wmsModuleCore.LocationEntityClass,
+            __from: { parentId: id },
+            __conditions: (qb) => qb.orderBy('entity."key"', 'ASC'),
+        });
     }
 };
 tslib.__decorate([
@@ -3634,9 +3722,10 @@ tslib.__decorate([
 tslib.__decorate([
     graphql.ResolveField(() => [LocationDto]),
     tslib.__param(0, graphql.Parent()),
+    tslib.__param(1, graphql.Context()),
     tslib.__metadata("design:type", Function),
-    tslib.__metadata("design:paramtypes", [wmsModuleCore.LocationEntityClass]),
-    tslib.__metadata("design:returntype", void 0)
+    tslib.__metadata("design:paramtypes", [wmsModuleCore.LocationEntityClass, Object]),
+    tslib.__metadata("design:returntype", Promise)
 ], LocationResolver.prototype, "children", null);
 LocationResolver = tslib.__decorate([
     graphql.Resolver(() => LocationDto)
@@ -3829,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 },
         });
     }
@@ -3905,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 {
@@ -4291,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 },
         });
     }
@@ -4413,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 {
@@ -4709,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 },
         });
     }
@@ -4757,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 {
@@ -4781,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 },
         });
     }
@@ -4866,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 {
@@ -5203,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 },
         });
     }
@@ -5333,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,
@@ -5350,7 +5513,7 @@ let ShipInventoryOrderReferenceResolver = class ShipInventoryOrderReferenceResol
     }
     material({ materialId }, { loaders }) {
         return loaders.batchSingle.load({
-            __entity: wmsModuleCore.MaterialEntityClass,
+            __entity: this.materialEntity,
             __from: { id: materialId },
         });
     }
@@ -5406,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;
@@ -33,6 +39,28 @@ export declare class LoaderService {
      * @returns Map<string, data>
      */
     private useIndex;
+    /**
+     * resolve a `__from` property name to the physical column it is stored in.
+     *
+     * TypeORM's `FindOptionsWhere` only accepts real column properties. A
+     * `@RelationId()` property — e.g. `LocationEntityClass.parentId`, which mirrors
+     * the `parent` tree relation — is virtual and is rejected with
+     * `EntityPropertyNotFoundError`, even though it is backed by the relation's
+     * join column. Map those back to their join column so they stay batchable.
+     * @param EntityMetadata
+     * @param string
+     * @returns string | null
+     */
+    private resolveColumnName;
+    /**
+     * build the where clause for `__from` keys that TypeORM's find options cannot
+     * express (see {@link resolveColumnName}), by addressing the columns directly.
+     * @param SelectQueryBuilder
+     * @param EntityMetadata
+     * @param LoaderOptions[]
+     * @param (keyof T)[]
+     */
+    private applyColumnWhere;
     /**
      * query data by collecting primary keys from options with same `__entity`
      * @param LoaderOptions[]

package/lib/helpers/loader.service.js

@@ -3,7 +3,7 @@ import { Injectable } from '@nestjs/common';
 import { createHash } from 'crypto';
 import _ from 'lodash';
 import { LRUCache } from 'lru-cache';
-import { DataSource, In } from 'typeorm';
+import { DataSource, Brackets, In } from 'typeorm';
 import DataLoader from 'dataloader';
 
 let LoaderService = class LoaderService {
@@ -42,6 +42,65 @@ let LoaderService = class LoaderService {
         const fields = _(Object.keys(__from)).sort();
         return `${__hash}_${fields.map((field) => data[field]).join('_')}`;
     }
+    /**
+     * resolve a `__from` property name to the physical column it is stored in.
+     *
+     * TypeORM's `FindOptionsWhere` only accepts real column properties. A
+     * `@RelationId()` property — e.g. `LocationEntityClass.parentId`, which mirrors
+     * the `parent` tree relation — is virtual and is rejected with
+     * `EntityPropertyNotFoundError`, even though it is backed by the relation's
+     * join column. Map those back to their join column so they stay batchable.
+     * @param EntityMetadata
+     * @param string
+     * @returns string | null
+     */
+    resolveColumnName(metadata, propertyName) {
+        const column = metadata.findColumnWithPropertyName(propertyName);
+        if (column)
+            return column.databaseName;
+        const relationId = metadata.relationIds.find((candidate) => candidate.propertyName === propertyName);
+        const joinColumns = relationId?.relation.joinColumns ?? [];
+        return joinColumns.length === 1 ? joinColumns[0].databaseName : null;
+    }
+    /**
+     * build the where clause for `__from` keys that TypeORM's find options cannot
+     * express (see {@link resolveColumnName}), by addressing the columns directly.
+     * @param SelectQueryBuilder
+     * @param EntityMetadata
+     * @param LoaderOptions[]
+     * @param (keyof T)[]
+     */
+    applyColumnWhere(qb, metadata, options, primaryKeys) {
+        const columns = primaryKeys.map((primaryKey) => {
+            const columnName = this.resolveColumnName(metadata, String(primaryKey));
+            if (!columnName)
+                throw new Error(`Loader cannot resolve property "${String(primaryKey)}" to a column of "${metadata.name}".`);
+            return {
+                primaryKey,
+                column: `entity.${this.dataSource.driver.escape(columnName)}`,
+            };
+        });
+        if (columns.length === 1) {
+            const [{ primaryKey, column }] = columns;
+            qb.andWhere(`${column} IN (:...wmsLoaderValues)`, {
+                wmsLoaderValues: options.map(({ __from }) => __from[primaryKey]),
+            });
+            return;
+        }
+        qb.andWhere(new Brackets((where) => {
+            options.forEach(({ __from }, optionIndex) => {
+                const parameters = {};
+                const predicate = columns
+                    .map(({ primaryKey, column }, columnIndex) => {
+                    const parameter = `wmsLoaderValue_${optionIndex}_${columnIndex}`;
+                    parameters[parameter] = __from[primaryKey];
+                    return `${column} = :${parameter}`;
+                })
+                    .join(' AND ');
+                where.orWhere(`(${predicate})`, parameters);
+            });
+        }));
+    }
     /**
      * query data by collecting primary keys from options with same `__entity`
      * @param LoaderOptions[]
@@ -52,7 +111,10 @@ let LoaderService = class LoaderService {
         const repo = this.dataSource.getRepository(__entity);
         let qb = repo.createQueryBuilder('entity');
         const primaryKeys = Object.keys(__from);
-        if (primaryKeys.length > 1)
+        const hasVirtualKey = primaryKeys.some((primaryKey) => !repo.metadata.findColumnWithPropertyName(String(primaryKey)));
+        if (hasVirtualKey)
+            this.applyColumnWhere(qb, repo.metadata, options, primaryKeys);
+        else if (primaryKeys.length > 1)
             qb.setFindOptions({ where: options.map(({ __from }) => __from) });
         else {
             const [primaryKey] = primaryKeys;

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/location.resolver.d.ts

@@ -6,5 +6,14 @@ import { LocationEntityClass } from '@rytass/wms-module-core';
 export declare class LocationResolver {
     mapData({ id }: LocationDto, { loaders }: LoaderType<WarehouseMapEntity>): Promise<MapDataDto | null>;
     parent({ parentId }: LocationEntityClass, { loaders }: LoaderType<LocationEntityClass>): Promise<LocationEntityClass> | null;
-    children({ children }: LocationEntityClass): import("@rytass/wms-base-nestjs-module").LocationEntity[];
+    /**
+     * `children` must never be read off the parent entity: only
+     * `LocationQuery.location` and `LocationService.findMany` eager-load the tree
+     * relation. Every other producer of a `LocationDto` (stock/loader/change-log/
+     * transfer/ship/receive/warehouse-map resolvers, the `parent` field above and
+     * the create/update mutations) hands back an entity whose `children` is
+     * `undefined`, which breaks the non-nullable list. Always resolve through the
+     * request-scoped loader instead.
+     */
+    children({ id }: LocationEntityClass, { loaders }: LoaderType<LocationEntityClass>): Promise<LocationDto[]>;
 }

package/lib/resolvers/location.resolver.js

@@ -21,8 +21,21 @@ let LocationResolver = class LocationResolver {
             __from: { id: parentId },
         });
     }
-    children({ children }) {
-        return children;
+    /**
+     * `children` must never be read off the parent entity: only
+     * `LocationQuery.location` and `LocationService.findMany` eager-load the tree
+     * relation. Every other producer of a `LocationDto` (stock/loader/change-log/
+     * transfer/ship/receive/warehouse-map resolvers, the `parent` field above and
+     * the create/update mutations) hands back an entity whose `children` is
+     * `undefined`, which breaks the non-nullable list. Always resolve through the
+     * request-scoped loader instead.
+     */
+    children({ id }, { loaders }) {
+        return loaders.batchMany.load({
+            __entity: LocationEntityClass,
+            __from: { parentId: id },
+            __conditions: (qb) => qb.orderBy('entity."key"', 'ASC'),
+        });
     }
 };
 __decorate([
@@ -44,9 +57,10 @@ __decorate([
 __decorate([
     ResolveField(() => [LocationDto]),
     __param(0, Parent()),
+    __param(1, Context()),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [LocationEntityClass]),
-    __metadata("design:returntype", void 0)
+    __metadata("design:paramtypes", [LocationEntityClass, Object]),
+    __metadata("design:returntype", Promise)
 ], LocationResolver.prototype, "children", null);
 LocationResolver = __decorate([
     Resolver(() => LocationDto)

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.0",
+  "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.0",
+    "@rytass/wms-module-core": "^0.4.0",
     "graphql": "^16.0.0",
     "reflect-metadata": "^0.1.13 || ^0.2.0",
     "rxjs": "^7.8.0",