@rytass/wms-module-graphql 0.7.0 → 0.9.0

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

@@ -1,5 +1,4 @@
 import { __decorate, __param, __metadata } from 'tslib';
-import { Inject } from '@nestjs/common';
 import { ResolveField, Parent, Context, Resolver, ID, Int } from '@nestjs/graphql';
 import '../dto/loader-type.dto.js';
 import { LoaderDto } from '../dto/loader.dto.js';
@@ -25,7 +24,8 @@ import '../dto/scrape-order.dto.js';
 import '../dto/scrape-order-item.dto.js';
 import '../dto/quality-inspection-order.dto.js';
 import '../dto/quality-inspection-order-item.dto.js';
-import { ShipInventoryOrderEntityClass, ShipInventoryOrderItemEntityClass, MaterialEntity, ShipInventoryOrderReferenceEntityClass, BatchEntityClass, BatchGroupEntityClass, LocationEntityClass, LoadersEntityClass, ShipInventoryOrderChangeEntityClass } from '@rytass/wms-module-core';
+import '../dto/inventory-count-order.dto.js';
+import { ShipInventoryOrderEntityClass, ShipInventoryOrderItemEntityClass, WmsEntities, ShipInventoryOrderReferenceEntityClass, BatchGroupEntityClass, LoadersEntityClass, ShipInventoryOrderChangeEntityClass } from '@rytass/wms-module-core';
 import { BatchDto } from '../dto/batch.dto.js';
 import { LocationDto } from '../dto/location.dto.js';
 import { ShipInventoryOrderReferenceDto } from '../dto/ship-inventory-order-reference.dto.js';
@@ -65,20 +65,20 @@ ShipInventoryOrderResolver = __decorate([
     Resolver(() => ShipInventoryOrderDto)
 ], ShipInventoryOrderResolver);
 let ShipInventoryOrderItemResolver = class ShipInventoryOrderItemResolver {
-    materialEntity;
+    entities;
     /**
-     * Bound to the `MaterialEntity` Symbol, so the DataLoader queries whichever
-     * material entity the consumer configured — the built-in `MaterialEntityClass`
-     * unless `materialEntity` was passed to `forRoot`/`forRootAsync`. Loading the
-     * built-in class outright would filter on its single-table-inheritance
-     * discriminator and resolve nothing for a custom entity.
+     * The configured entities, not the built-in classes: `__entity` decides which
+     * repository the DataLoader opens, so it has to follow whatever the consumer
+     * passed to `WMSBaseModuleOptions`. Loading a built-in class outright filters
+     * on its single-table-inheritance discriminator and resolves nothing for an
+     * override.
      */
-    constructor(materialEntity) {
-        this.materialEntity = materialEntity;
+    constructor(entities) {
+        this.entities = entities;
     }
     material({ materialId }, { loaders }) {
         return loaders.batchSingle.load({
-            __entity: this.materialEntity,
+            __entity: this.entities.material,
             __from: { id: materialId },
         });
     }
@@ -86,7 +86,7 @@ let ShipInventoryOrderItemResolver = class ShipInventoryOrderItemResolver {
         if (!batchId)
             return null;
         const { groupId } = await loaders.batchSingle.load({
-            __entity: BatchEntityClass,
+            __entity: this.entities.batch,
             __from: { id: batchId },
         });
         return loaders.batchSingle.load({
@@ -98,7 +98,7 @@ let ShipInventoryOrderItemResolver = class ShipInventoryOrderItemResolver {
         if (!batchId)
             return null;
         const { groupId } = await loaders.batchSingle.load({
-            __entity: BatchEntityClass,
+            __entity: this.entities.batch,
             __from: { id: batchId },
         });
         return loaders.batchSingle
@@ -112,7 +112,7 @@ let ShipInventoryOrderItemResolver = class ShipInventoryOrderItemResolver {
         if (!batchId)
             return null;
         const { groupId } = await loaders.batchSingle.load({
-            __entity: BatchEntityClass,
+            __entity: this.entities.batch,
             __from: { id: batchId },
         });
         return loaders.batchSingle
@@ -126,7 +126,7 @@ let ShipInventoryOrderItemResolver = class ShipInventoryOrderItemResolver {
         if (!locationId)
             return null;
         return loaders.batchSingle.load({
-            __entity: LocationEntityClass,
+            __entity: this.entities.location,
             __from: { id: locationId },
         });
     }
@@ -207,20 +207,19 @@ __decorate([
 ], ShipInventoryOrderItemResolver.prototype, "shippedQuantity", null);
 ShipInventoryOrderItemResolver = __decorate([
     Resolver(() => ShipInventoryOrderItemDto),
-    __param(0, Inject(MaterialEntity)),
-    __metadata("design:paramtypes", [Function])
+    __metadata("design:paramtypes", [WmsEntities])
 ], ShipInventoryOrderItemResolver);
 let ShipInventoryOrderReferenceResolver = class ShipInventoryOrderReferenceResolver {
-    materialEntity;
+    entities;
     /**
-     * Bound to the `MaterialEntity` Symbol, so the DataLoader queries whichever
-     * material entity the consumer configured — the built-in `MaterialEntityClass`
-     * unless `materialEntity` was passed to `forRoot`/`forRootAsync`. Loading the
-     * built-in class outright would filter on its single-table-inheritance
-     * discriminator and resolve nothing for a custom entity.
+     * The configured entities, not the built-in classes: `__entity` decides which
+     * repository the DataLoader opens, so it has to follow whatever the consumer
+     * passed to `WMSBaseModuleOptions`. Loading a built-in class outright filters
+     * on its single-table-inheritance discriminator and resolves nothing for an
+     * override.
      */
-    constructor(materialEntity) {
-        this.materialEntity = materialEntity;
+    constructor(entities) {
+        this.entities = entities;
     }
     async shippedQuantity({ orderId, serialId }, { loaders }) {
         const items = await loaders.batchMany.load({
@@ -236,7 +235,7 @@ let ShipInventoryOrderReferenceResolver = class ShipInventoryOrderReferenceResol
     }
     material({ materialId }, { loaders }) {
         return loaders.batchSingle.load({
-            __entity: this.materialEntity,
+            __entity: this.entities.material,
             __from: { id: materialId },
         });
     }
@@ -244,7 +243,7 @@ let ShipInventoryOrderReferenceResolver = class ShipInventoryOrderReferenceResol
         if (!batchId)
             return null;
         const { groupId } = await loaders.batchSingle.load({
-            __entity: BatchEntityClass,
+            __entity: this.entities.batch,
             __from: { id: batchId },
         });
         return loaders.batchSingle.load({
@@ -293,8 +292,7 @@ __decorate([
 ], ShipInventoryOrderReferenceResolver.prototype, "items", null);
 ShipInventoryOrderReferenceResolver = __decorate([
     Resolver(() => ShipInventoryOrderReferenceDto),
-    __param(0, Inject(MaterialEntity)),
-    __metadata("design:paramtypes", [Function])
+    __metadata("design:paramtypes", [WmsEntities])
 ], ShipInventoryOrderReferenceResolver);
 
 export { ShipInventoryOrderItemResolver, ShipInventoryOrderReferenceResolver, ShipInventoryOrderResolver };

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

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

package/lib/resolvers/stock.resolver.js

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

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

@@ -1,25 +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 materialEntity;
+    private readonly entities;
     /**
-     * Bound to the `MaterialEntity` Symbol, so the DataLoader queries whichever
-     * material entity the consumer configured — the built-in `MaterialEntityClass`
-     * unless `materialEntity` was passed to `forRoot`/`forRootAsync`. Loading the
-     * built-in class outright would filter on its single-table-inheritance
-     * discriminator and resolve nothing for a custom entity.
+     * The configured entities, not the built-in classes: `__entity` decides which
+     * repository the DataLoader opens, so it has to follow whatever the consumer
+     * passed to `WMSBaseModuleOptions`. Loading a built-in class outright filters
+     * on its single-table-inheritance discriminator and resolves nothing for an
+     * override.
      */
-    constructor(materialEntity: new () => MaterialEntityClass);
+    constructor(entities: WmsEntities);
     material({ materialId }: 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,9 +1,8 @@
 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, MaterialEntity, LocationEntityClass, LoadersEntityClass, 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';
@@ -26,10 +25,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 '../dto/inventory-count-order.dto.js';
 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,
@@ -44,7 +55,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 },
         });
     }
@@ -88,23 +99,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 {
-    materialEntity;
+    entities;
     /**
-     * Bound to the `MaterialEntity` Symbol, so the DataLoader queries whichever
-     * material entity the consumer configured — the built-in `MaterialEntityClass`
-     * unless `materialEntity` was passed to `forRoot`/`forRootAsync`. Loading the
-     * built-in class outright would filter on its single-table-inheritance
-     * discriminator and resolve nothing for a custom entity.
+     * The configured entities, not the built-in classes: `__entity` decides which
+     * repository the DataLoader opens, so it has to follow whatever the consumer
+     * passed to `WMSBaseModuleOptions`. Loading a built-in class outright filters
+     * on its single-table-inheritance discriminator and resolves nothing for an
+     * override.
      */
-    constructor(materialEntity) {
-        this.materialEntity = materialEntity;
+    constructor(entities) {
+        this.entities = entities;
     }
     material({ materialId }, { loaders }) {
         return loaders.batchSingle.load({
-            __entity: this.materialEntity,
+            __entity: this.entities.material,
             __from: { id: materialId },
         });
     }
@@ -112,7 +124,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({
@@ -124,7 +136,7 @@ let TransferOrderItemResolver = class TransferOrderItemResolver {
         if (!locationId)
             return null;
         return loaders.batchSingle.load({
-            __entity: LocationEntityClass,
+            __entity: this.entities.location,
             __from: { id: locationId },
         });
     }
@@ -141,7 +153,7 @@ let TransferOrderItemResolver = class TransferOrderItemResolver {
             return null;
         return loaders.batchSingle
             .load({
-            __entity: BatchEntityClass,
+            __entity: this.entities.batch,
             __from: { id: batchId },
         })
             .then((batch) => batch.saleId);
@@ -151,7 +163,7 @@ let TransferOrderItemResolver = class TransferOrderItemResolver {
             return null;
         return loaders.batchSingle
             .load({
-            __entity: BatchEntityClass,
+            __entity: this.entities.batch,
             __from: { id: batchId },
         })
             .then((batch) => batch.saleSerialId);
@@ -225,8 +237,7 @@ __decorate([
 ], TransferOrderItemResolver.prototype, "transferredQuantity", null);
 TransferOrderItemResolver = __decorate([
     Resolver(() => TransferOrderItemDto),
-    __param(0, Inject(MaterialEntity)),
-    __metadata("design:paramtypes", [Function])
+    __metadata("design:paramtypes", [WmsEntities])
 ], TransferOrderItemResolver);
 
 export { TransferOrderItemResolver, TransferOrderResolver };

package/lib/resolvers/warehouse-map.resolver.d.ts

@@ -1,6 +1,15 @@
 import { type LoaderType } from '../helpers';
-import { LocationEntityClass } from '@rytass/wms-module-core';
+import { LocationEntityClass, WmsEntities } from '@rytass/wms-module-core';
 import { MapRangeDto } from '../dto/warehouse-map.dto';
 export declare class MapRangeUnionResolver {
+    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);
     location({ id }: MapRangeDto, { loaders }: LoaderType<LocationEntityClass>): Promise<LocationEntityClass> | null;
 }

package/lib/resolvers/warehouse-map.resolver.js

@@ -1,15 +1,26 @@
 import { __decorate, __param, __metadata } from 'tslib';
 import { ResolveField, Parent, Context, Resolver } from '@nestjs/graphql';
 import { LocationDto } from '../dto/location.dto.js';
-import { LocationEntityClass } from '@rytass/wms-module-core';
+import { WmsEntities } from '@rytass/wms-module-core';
 import { MapRangeDto } from '../dto/warehouse-map.dto.js';
 
 let MapRangeUnionResolver = class MapRangeUnionResolver {
+    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;
+    }
     location({ id }, { loaders }) {
         if (!id)
             return null;
         return loaders.batchSingle.load({
-            __entity: LocationEntityClass,
+            __entity: this.entities.location,
             __from: { key: id },
         });
     }
@@ -23,7 +34,8 @@ __decorate([
     __metadata("design:returntype", void 0)
 ], MapRangeUnionResolver.prototype, "location", null);
 MapRangeUnionResolver = __decorate([
-    Resolver(() => MapRangeDto)
+    Resolver(() => MapRangeDto),
+    __metadata("design:paramtypes", [WmsEntities])
 ], MapRangeUnionResolver);
 
 export { MapRangeUnionResolver };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rytass/wms-module-graphql",
-  "version": "0.7.0",
+  "version": "0.9.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.4.0",
+    "@rytass/wms-module-core": "^0.6.0",
     "graphql": "^16.0.0",
     "reflect-metadata": "^0.1.13 || ^0.2.0",
     "rxjs": "^7.8.0",