@rytass/wms-module-graphql 0.10.2 → 0.11.0

package/lib/queries/consumption-order.query.d.ts

@@ -0,0 +1,9 @@
+import { ConsumptionOrderService } from '@rytass/wms-module-core';
+import { ConsumptionOrderDto, ConsumptionOrders } from '../dto/consumption-order.dto';
+import { FindConsumptionOrderArgs } from '../inputs/consumption-order.args';
+export declare class ConsumptionOrderQuery {
+    private readonly consumptionOrderService;
+    constructor(consumptionOrderService: ConsumptionOrderService);
+    consumptionOrder(id: string): Promise<ConsumptionOrderDto>;
+    consumptionOrders(args: FindConsumptionOrderArgs): Promise<ConsumptionOrders>;
+}

package/lib/queries/consumption-order.query.js

@@ -0,0 +1,45 @@
+import { __decorate, __param, __metadata } from 'tslib';
+import { Injectable } from '@nestjs/common';
+import { Query, Args, ID, Resolver } from '@nestjs/graphql';
+import { ConsumptionOrderService } from '@rytass/wms-module-core';
+import { ConsumptionOrderDto, ConsumptionOrders } from '../dto/consumption-order.dto.js';
+import { FindConsumptionOrderArgs } from '../inputs/consumption-order.args.js';
+import '../auth/wms-auth.guard.js';
+import { WmsOperation } from '../auth/wms-operation.decorator.js';
+
+let ConsumptionOrderQuery = class ConsumptionOrderQuery {
+    consumptionOrderService;
+    constructor(consumptionOrderService) {
+        this.consumptionOrderService = consumptionOrderService;
+    }
+    consumptionOrder(id) {
+        return this.consumptionOrderService.findOne(id);
+    }
+    async consumptionOrders(args) {
+        const [items, total] = await this.consumptionOrderService.findMany(args);
+        return { items, total };
+    }
+};
+__decorate([
+    Query(() => ConsumptionOrderDto),
+    WmsOperation({ resource: 'consumption-order', action: 'read' }),
+    __param(0, Args('id', { type: () => ID })),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], ConsumptionOrderQuery.prototype, "consumptionOrder", null);
+__decorate([
+    Query(() => ConsumptionOrders),
+    WmsOperation({ resource: 'consumption-order', action: 'read' }),
+    __param(0, Args()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [FindConsumptionOrderArgs]),
+    __metadata("design:returntype", Promise)
+], ConsumptionOrderQuery.prototype, "consumptionOrders", null);
+ConsumptionOrderQuery = __decorate([
+    Injectable(),
+    Resolver(),
+    __metadata("design:paramtypes", [ConsumptionOrderService])
+], ConsumptionOrderQuery);
+
+export { ConsumptionOrderQuery };

package/lib/queries/loader.query.js

@@ -27,6 +27,9 @@ 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 '../dto/consumption-order.dto.js';
+import '../dto/consumption-order-item.dto.js';
+import '../dto/order-reference.dto.js';
 import { FindLoaderArgs } from '../inputs/find-loader.args.js';
 import { FindLoaderTypeArgs } from '../inputs/find-loader-type.args.js';
 import { LoaderUnitDto, LoaderUnit } from '../dto/loader-unit.dto.js';

package/lib/queries/material.query.js

@@ -26,6 +26,9 @@ 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 '../dto/consumption-order.dto.js';
+import '../dto/consumption-order-item.dto.js';
+import '../dto/order-reference.dto.js';
 import { MaterialService } from '@rytass/wms-module-core';
 import { FindMaterialArgs } from '../inputs/find-material.args.js';
 import '../auth/wms-auth.guard.js';

package/lib/queries/order-reference.query.d.ts

@@ -0,0 +1,8 @@
+import { OrderReferenceService } from '@rytass/wms-module-core';
+import { OrderReferences } from '../dto/order-reference.dto';
+import { FindOrderReferenceArgs } from '../inputs/order-reference.args';
+export declare class OrderReferenceQuery {
+    private readonly orderReferenceService;
+    constructor(orderReferenceService: OrderReferenceService);
+    orderReferences(args: FindOrderReferenceArgs): Promise<OrderReferences>;
+}

package/lib/queries/order-reference.query.js

@@ -0,0 +1,34 @@
+import { __decorate, __param, __metadata } from 'tslib';
+import { Injectable } from '@nestjs/common';
+import { Query, Args, Resolver } from '@nestjs/graphql';
+import { OrderReferenceService } from '@rytass/wms-module-core';
+import { OrderReferences } from '../dto/order-reference.dto.js';
+import { FindOrderReferenceArgs } from '../inputs/order-reference.args.js';
+import '../auth/wms-auth.guard.js';
+import { WmsOperation } from '../auth/wms-operation.decorator.js';
+
+let OrderReferenceQuery = class OrderReferenceQuery {
+    orderReferenceService;
+    constructor(orderReferenceService) {
+        this.orderReferenceService = orderReferenceService;
+    }
+    async orderReferences(args) {
+        const [items, total] = await this.orderReferenceService.findMany(args);
+        return { items, total };
+    }
+};
+__decorate([
+    Query(() => OrderReferences),
+    WmsOperation({ resource: 'order-reference', action: 'read' }),
+    __param(0, Args()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [FindOrderReferenceArgs]),
+    __metadata("design:returntype", Promise)
+], OrderReferenceQuery.prototype, "orderReferences", null);
+OrderReferenceQuery = __decorate([
+    Injectable(),
+    Resolver(),
+    __metadata("design:paramtypes", [OrderReferenceService])
+], OrderReferenceQuery);
+
+export { OrderReferenceQuery };

package/lib/queries/recieve-inventory-order.query.js

@@ -27,6 +27,9 @@ 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 '../dto/consumption-order.dto.js';
+import '../dto/consumption-order-item.dto.js';
+import '../dto/order-reference.dto.js';
 import { FindReceiveInventoryOrderArgs } from '../inputs/find-receive-inventory-order.args.js';
 import '../auth/wms-auth.guard.js';
 import { WmsOperation } from '../auth/wms-operation.decorator.js';

package/lib/queries/ship-inventory-order.query.js

@@ -27,6 +27,9 @@ 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 '../dto/consumption-order.dto.js';
+import '../dto/consumption-order-item.dto.js';
+import '../dto/order-reference.dto.js';
 import { FindShipInventoryOrderArgs } from '../inputs/find-ship-inventory-order.args.js';
 import '../auth/wms-auth.guard.js';
 import { WmsOperation } from '../auth/wms-operation.decorator.js';

package/lib/queries/stock.query.js

@@ -27,6 +27,9 @@ 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 '../dto/consumption-order.dto.js';
+import '../dto/consumption-order-item.dto.js';
+import '../dto/order-reference.dto.js';
 import { FindStockArgs } from '../inputs/find-stock.args.js';
 import '../auth/wms-auth.guard.js';
 import { WmsOperation } from '../auth/wms-operation.decorator.js';

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

@@ -25,6 +25,9 @@ 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 '../dto/consumption-order.dto.js';
+import '../dto/consumption-order-item.dto.js';
+import '../dto/order-reference.dto.js';
 import { StockService, WmsEntities, BatchGroupEntityClass, LoadersEntityClass } from '@rytass/wms-module-core';
 import { BatchDto } from '../dto/batch.dto.js';
 import { LocationDto } from '../dto/location.dto.js';

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

@@ -25,6 +25,9 @@ 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 '../dto/consumption-order.dto.js';
+import '../dto/consumption-order-item.dto.js';
+import '../dto/order-reference.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';

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

@@ -0,0 +1,40 @@
+import { BatchEntityClass, ConsumptionOrderChangeEntityClass, ConsumptionOrderItemEntityClass, LoadersEntityClass, LocationEntityClass, MaterialEntityClass, WmsEntities } from '@rytass/wms-module-core';
+import { ConsumptionOrderDto } from '../dto/consumption-order.dto';
+import { ConsumptionOrderItemDto } from '../dto/consumption-order-item.dto';
+import { LoaderDto, MaterialDto } from '../dto';
+import { BatchDto } from '../dto/batch.dto';
+import { LocationDto } from '../dto/location.dto';
+import { type LoaderType } from '../helpers';
+export declare class ConsumptionOrderResolver {
+    items({ id }: ConsumptionOrderDto, { loaders }: LoaderType<ConsumptionOrderItemEntityClass>): Promise<ConsumptionOrderItemDto[]>;
+}
+export declare class ConsumptionOrderItemResolver {
+    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);
+    /**
+     * How much this line has moved, by kind.
+     *
+     * Read back from the changes rather than denormalised onto the item: the
+     * changes are what the stock ledger and the `stock.*` events agree with, and a
+     * counter maintained alongside them is a second answer waiting to disagree.
+     */
+    private movedQuantity;
+    material({ materialId }: ConsumptionOrderItemEntityClass, { loaders }: LoaderType<MaterialEntityClass>): Promise<MaterialDto>;
+    batch({ batchId }: ConsumptionOrderItemEntityClass, { loaders }: LoaderType<BatchEntityClass>): Promise<BatchDto | null>;
+    location({ locationId }: ConsumptionOrderItemEntityClass, { loaders }: LoaderType<LocationEntityClass>): Promise<LocationDto | null>;
+    targetLocation({ targetLocationId }: ConsumptionOrderItemEntityClass, { loaders }: LoaderType<LocationEntityClass>): Promise<LocationDto | null>;
+    loader({ loaderId }: ConsumptionOrderItemEntityClass, { loaders }: LoaderType<LoadersEntityClass>): Promise<LoaderDto | null>;
+    targetLoader({ targetLoaderId }: ConsumptionOrderItemEntityClass, { loaders }: LoaderType<LoadersEntityClass>): Promise<LoaderDto | null>;
+    issuedQuantity({ id }: ConsumptionOrderItemEntityClass, { loaders }: LoaderType<ConsumptionOrderChangeEntityClass>): Promise<number>;
+    returnedQuantity({ id }: ConsumptionOrderItemEntityClass, { loaders }: LoaderType<ConsumptionOrderChangeEntityClass>): Promise<number>;
+    settledQuantity({ id }: ConsumptionOrderItemEntityClass, { loaders }: LoaderType<ConsumptionOrderChangeEntityClass>): Promise<number>;
+    /** Issued minus returned minus settled: what the process still holds. */
+    outstandingQuantity({ id }: ConsumptionOrderItemEntityClass, { loaders }: LoaderType<ConsumptionOrderChangeEntityClass>): Promise<number>;
+}

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

@@ -0,0 +1,238 @@
+import { __decorate, __param, __metadata } from 'tslib';
+import { ResolveField, Parent, Context, Resolver, Float } from '@nestjs/graphql';
+import { ConsumptionOrderItemEntityClass, WmsEntities, ConsumptionOrderChangeEntityClass, BatchGroupEntityClass, LoadersEntityClass, ConsumptionChangeKind } from '@rytass/wms-module-core';
+import { ConsumptionOrderDto } from '../dto/consumption-order.dto.js';
+import { ConsumptionOrderItemDto } from '../dto/consumption-order-item.dto.js';
+import '../dto/loader-type.dto.js';
+import { LoaderDto } from '../dto/loader.dto.js';
+import { MaterialDto } from '../dto/material.dto.js';
+import '../dto/material-unit.dto.js';
+import '../dto/stock.dto.js';
+import '../dto/sale-order.dto.js';
+import '../dto/receive-inventory-order.dto.js';
+import '../dto/receive-inventory-order-item.dto.js';
+import '../dto/ship-inventory-order.dto.js';
+import '../dto/ship-inventory-order-item.dto.js';
+import '../dto/hold-inventory-order.dto.js';
+import '../dto/hold-inventory-order-item.dto.js';
+import '../dto/allocate-inventory-order.dto.js';
+import '../dto/allocate-inventory-order-item.dto.js';
+import '../dto/transfer-order.dto.js';
+import '../dto/transfer-order-item.dto.js';
+import '../dto/transfer-customer-order.dto.js';
+import '../dto/transfer-customer-order-item.dto.js';
+import '../dto/transfer-vendor-order.dto.js';
+import '../dto/transfer-vendor-order-item.dto.js';
+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 '../dto/order-reference.dto.js';
+import { BatchDto } from '../dto/batch.dto.js';
+import { LocationDto } from '../dto/location.dto.js';
+
+let ConsumptionOrderResolver = class ConsumptionOrderResolver {
+    items({ id }, { loaders }) {
+        return loaders.batchMany.load({
+            __entity: ConsumptionOrderItemEntityClass,
+            __from: { orderId: id },
+        });
+    }
+};
+__decorate([
+    ResolveField(() => [ConsumptionOrderItemDto]),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ConsumptionOrderDto, Object]),
+    __metadata("design:returntype", Promise)
+], ConsumptionOrderResolver.prototype, "items", null);
+ConsumptionOrderResolver = __decorate([
+    Resolver(() => ConsumptionOrderDto)
+], ConsumptionOrderResolver);
+let ConsumptionOrderItemResolver = class ConsumptionOrderItemResolver {
+    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;
+    }
+    /**
+     * How much this line has moved, by kind.
+     *
+     * Read back from the changes rather than denormalised onto the item: the
+     * changes are what the stock ledger and the `stock.*` events agree with, and a
+     * counter maintained alongside them is a second answer waiting to disagree.
+     */
+    async movedQuantity(itemId, kind, loaders) {
+        const changes = await loaders.batchMany.load({
+            __entity: ConsumptionOrderChangeEntityClass,
+            __from: { itemId },
+        });
+        return changes
+            .filter((change) => change.kind === kind)
+            .reduce((total, { quantityChanged }) => total + Math.abs(Number(quantityChanged)), 0);
+    }
+    material({ materialId }, { loaders }) {
+        return loaders.batchSingle.load({
+            __entity: this.entities.material,
+            __from: { id: materialId },
+        });
+    }
+    async batch({ batchId }, { loaders }) {
+        if (!batchId)
+            return null;
+        const { groupId } = await loaders.batchSingle.load({
+            __entity: this.entities.batch,
+            __from: { id: batchId },
+        });
+        return loaders.batchSingle.load({
+            __entity: BatchGroupEntityClass,
+            __from: { id: groupId },
+        });
+    }
+    async location({ locationId }, { loaders }) {
+        if (!locationId)
+            return null;
+        return loaders.batchSingle.load({
+            __entity: this.entities.location,
+            __from: { id: locationId },
+        });
+    }
+    async targetLocation({ targetLocationId }, { loaders }) {
+        if (!targetLocationId)
+            return null;
+        return loaders.batchSingle.load({
+            __entity: this.entities.location,
+            __from: { id: targetLocationId },
+        });
+    }
+    async loader({ loaderId }, { loaders }) {
+        if (!loaderId)
+            return null;
+        return loaders.batchSingle.load({
+            __entity: LoadersEntityClass,
+            __from: { id: loaderId },
+        });
+    }
+    async targetLoader({ targetLoaderId }, { loaders }) {
+        if (!targetLoaderId)
+            return null;
+        return loaders.batchSingle.load({
+            __entity: LoadersEntityClass,
+            __from: { id: targetLoaderId },
+        });
+    }
+    issuedQuantity({ id }, { loaders }) {
+        return this.movedQuantity(id, ConsumptionChangeKind.ISSUE, loaders);
+    }
+    returnedQuantity({ id }, { loaders }) {
+        return this.movedQuantity(id, ConsumptionChangeKind.RETURN, loaders);
+    }
+    settledQuantity({ id }, { loaders }) {
+        return this.movedQuantity(id, ConsumptionChangeKind.SETTLE, loaders);
+    }
+    /** Issued minus returned minus settled: what the process still holds. */
+    async outstandingQuantity({ id }, { loaders }) {
+        const changes = await loaders.batchMany.load({
+            __entity: ConsumptionOrderChangeEntityClass,
+            __from: { itemId: id },
+        });
+        // The sign already carries the direction here — an issue is positive, a
+        // return and a settlement negative — so the outstanding amount is just the
+        // sum, no filtering by kind needed.
+        return changes.reduce((total, { quantityChanged }) => total + Number(quantityChanged), 0);
+    }
+};
+__decorate([
+    ResolveField(() => MaterialDto),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ConsumptionOrderItemEntityClass, Object]),
+    __metadata("design:returntype", Promise)
+], ConsumptionOrderItemResolver.prototype, "material", null);
+__decorate([
+    ResolveField(() => BatchDto, { nullable: true }),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ConsumptionOrderItemEntityClass, Object]),
+    __metadata("design:returntype", Promise)
+], ConsumptionOrderItemResolver.prototype, "batch", null);
+__decorate([
+    ResolveField(() => LocationDto, { nullable: true }),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ConsumptionOrderItemEntityClass, Object]),
+    __metadata("design:returntype", Promise)
+], ConsumptionOrderItemResolver.prototype, "location", null);
+__decorate([
+    ResolveField(() => LocationDto, { nullable: true }),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ConsumptionOrderItemEntityClass, Object]),
+    __metadata("design:returntype", Promise)
+], ConsumptionOrderItemResolver.prototype, "targetLocation", null);
+__decorate([
+    ResolveField(() => LoaderDto, { nullable: true }),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ConsumptionOrderItemEntityClass, Object]),
+    __metadata("design:returntype", Promise)
+], ConsumptionOrderItemResolver.prototype, "loader", null);
+__decorate([
+    ResolveField(() => LoaderDto, { nullable: true }),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ConsumptionOrderItemEntityClass, Object]),
+    __metadata("design:returntype", Promise)
+], ConsumptionOrderItemResolver.prototype, "targetLoader", null);
+__decorate([
+    ResolveField(() => Float),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ConsumptionOrderItemEntityClass, Object]),
+    __metadata("design:returntype", Promise)
+], ConsumptionOrderItemResolver.prototype, "issuedQuantity", null);
+__decorate([
+    ResolveField(() => Float),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ConsumptionOrderItemEntityClass, Object]),
+    __metadata("design:returntype", Promise)
+], ConsumptionOrderItemResolver.prototype, "returnedQuantity", null);
+__decorate([
+    ResolveField(() => Float),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ConsumptionOrderItemEntityClass, Object]),
+    __metadata("design:returntype", Promise)
+], ConsumptionOrderItemResolver.prototype, "settledQuantity", null);
+__decorate([
+    ResolveField(() => Float),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ConsumptionOrderItemEntityClass, Object]),
+    __metadata("design:returntype", Promise)
+], ConsumptionOrderItemResolver.prototype, "outstandingQuantity", null);
+ConsumptionOrderItemResolver = __decorate([
+    Resolver(() => ConsumptionOrderItemDto),
+    __metadata("design:paramtypes", [WmsEntities])
+], ConsumptionOrderItemResolver);
+
+export { ConsumptionOrderItemResolver, ConsumptionOrderResolver };

package/lib/resolvers/loader-type.resolver.js

@@ -25,6 +25,9 @@ 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 '../dto/consumption-order.dto.js';
+import '../dto/consumption-order-item.dto.js';
+import '../dto/order-reference.dto.js';
 import { LoaderTypeEntityClass, LoadersEntityClass } from '@rytass/wms-module-core';
 
 let LoaderTypeResolver = class LoaderTypeResolver {

package/lib/resolvers/loader.resolver.js

@@ -25,6 +25,9 @@ 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 '../dto/consumption-order.dto.js';
+import '../dto/consumption-order-item.dto.js';
+import '../dto/order-reference.dto.js';
 import { LoadersEntityClass, WmsEntities, StockService, LoaderTypeEntityClass } from '@rytass/wms-module-core';
 import { LocationDto } from '../dto/location.dto.js';
 import _ from 'lodash';

package/lib/resolvers/material.resolver.js

@@ -25,6 +25,9 @@ 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 '../dto/consumption-order.dto.js';
+import '../dto/consumption-order-item.dto.js';
+import '../dto/order-reference.dto.js';
 import { MaterialEntityClass, StockService, MaterialUnitEntityClass, UnitEntityClass } from '@rytass/wms-module-core';
 import { UnitDto } from '../dto/unit.dto.js';
 

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

@@ -25,6 +25,9 @@ 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 '../dto/consumption-order.dto.js';
+import '../dto/consumption-order-item.dto.js';
+import '../dto/order-reference.dto.js';
 import { ReceiveInventoryOrderItemEntityClass, WmsEntities, BatchGroupEntityClass, LoadersEntityClass, ReceiveInventoryOrderChangeEntityClass } from '@rytass/wms-module-core';
 import { BatchDto } from '../dto/batch.dto.js';
 import { LocationDto } from '../dto/location.dto.js';

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

@@ -25,6 +25,9 @@ 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 '../dto/consumption-order.dto.js';
+import '../dto/consumption-order-item.dto.js';
+import '../dto/order-reference.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';

package/lib/resolvers/stock.resolver.js

@@ -25,6 +25,9 @@ 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 '../dto/consumption-order.dto.js';
+import '../dto/consumption-order-item.dto.js';
+import '../dto/order-reference.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';

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

@@ -26,6 +26,9 @@ 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 '../dto/consumption-order.dto.js';
+import '../dto/consumption-order-item.dto.js';
+import '../dto/order-reference.dto.js';
 import { BatchDto } from '../dto/batch.dto.js';
 import { LocationDto } from '../dto/location.dto.js';
 

package/lib/scalars/index.d.ts

@@ -0,0 +1 @@
+export { GraphQLJSONObject } from './json-object.scalar';

package/lib/scalars/json-object.scalar.d.ts

@@ -0,0 +1,2 @@
+import { GraphQLScalarType } from 'graphql';
+export declare const GraphQLJSONObject: GraphQLScalarType<Record<string, unknown>, Record<string, unknown>>;

package/lib/scalars/json-object.scalar.js

@@ -0,0 +1,62 @@
+import { GraphQLScalarType, Kind, GraphQLError } from 'graphql';
+
+/**
+ * A JSON object scalar, defined here rather than pulled from `graphql-type-json`
+ * so the package keeps its peer dependency list as it is — `graphql` is already
+ * required, and this is the whole of what we need from such a library.
+ *
+ * Deliberately narrower than "any JSON": the values it guards (a batch's
+ * host-defined `attributes`) are always a keyed record, and refusing a bare
+ * scalar or array at the edge means every consumer downstream can rely on that
+ * without re-checking.
+ */
+function parseLiteralValue(node) {
+    switch (node.kind) {
+        case Kind.STRING:
+        case Kind.BOOLEAN:
+            return node.value;
+        case Kind.INT:
+        case Kind.FLOAT:
+            return Number(node.value);
+        case Kind.NULL:
+            return null;
+        case Kind.LIST:
+            return node.values.map(parseLiteralValue);
+        case Kind.OBJECT:
+            return parseObjectLiteral(node);
+        default:
+            throw new GraphQLError(`JSONObject cannot represent a ${node.kind} literal`, { nodes: node });
+    }
+}
+function parseObjectLiteral(node) {
+    return node.fields.reduce((carry, field) => {
+        return { ...carry, [field.name.value]: parseLiteralValue(field.value) };
+    }, {});
+}
+function assertPlainObject(value) {
+    if (typeof value !== 'object' ||
+        value === null ||
+        Array.isArray(value) ||
+        // A Date or any other class instance serializes to something the host did
+        // not write; reject it here rather than let it reach the column.
+        Object.getPrototypeOf(value) !== Object.prototype) {
+        throw new GraphQLError('JSONObject must be a plain JSON object');
+    }
+    return value;
+}
+const GraphQLJSONObject = new GraphQLScalarType({
+    name: 'JSONObject',
+    description: 'An arbitrary JSON object supplied by the host. Its keys and values are stored verbatim and are never interpreted by this module.',
+    serialize: (value) => assertPlainObject(value),
+    parseValue: (value) => assertPlainObject(value),
+    parseLiteral: (node) => {
+        if (node.kind !== Kind.OBJECT) {
+            throw new GraphQLError('JSONObject must be an object literal', {
+                nodes: node,
+            });
+        }
+        return parseObjectLiteral(node);
+    },
+});
+
+export { GraphQLJSONObject };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rytass/wms-module-graphql",
-  "version": "0.10.2",
+  "version": "0.11.0",
   "description": "Rytass WMS Module — GraphQL schema, resolvers and DTOs for warehouse management",
   "keywords": [
     "rytass",
@@ -62,7 +62,7 @@
     "@nestjs/core": "^10.0.0 || ^11.0.0",
     "@nestjs/graphql": "^13.0.0",
     "@rytass/wms-base-nestjs-module": "^0.4.0",
-    "@rytass/wms-module-core": "^0.8.1",
+    "@rytass/wms-module-core": "^0.9.0",
     "graphql": "^16.0.0",
     "reflect-metadata": "^0.1.13 || ^0.2.0",
     "rxjs": "^7.0.0",