@rytass/wms-module-graphql 0.10.1 → 0.11.0

package/index.cjs.js

@@ -11,6 +11,7 @@ var DataLoader = require('dataloader');
 var graphql = require('@nestjs/graphql');
 var core = require('@nestjs/core');
 var rxjs = require('rxjs');
+var graphql$1 = require('graphql');
 var wmsBaseNestjsModule = require('@rytass/wms-base-nestjs-module');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
@@ -369,32 +370,24 @@ const WmsOperation = (requirement) => common.applyDecorators(common.SetMetadata(
 /** Reflector metadata key carrying the {@link WmsMutationEventConfig}. */
 const WMS_MUTATION_EVENT_METADATA = 'wms:mutation-event';
 
-const defaultResolveId = (result, args) => {
-    if (result &&
-        typeof result === 'object' &&
-        'id' in result &&
-        typeof result.id === 'string') {
-        return result.id;
-    }
-    const argId = args['id'];
-    return typeof argId === 'string' ? argId : null;
-};
 /**
- * Wraps each `@WmsMutationEvent` mutation in a dispatch scope:
- * 1. runs the before-hook (throw -> veto, before any transaction);
- * 2. executes the resolver (services collect stock events into the scope);
- * 3. emits the operation event after the handler resolves (post-commit);
- * 4. flushes the whole buffer to after-listeners + emitter bridge.
+ * Hands each `@WmsMutationEvent` mutation to {@link WmsOperationRunner}, which
+ * owns the before-hook / dispatch scope / post-commit flush sequence.
  *
- * When no hook/listener/bridge is configured it passes through untouched.
+ * All this adds on top is what only a GraphQL request can supply: the raw
+ * arguments and the actor. Keeping the sequence itself in core is what stops
+ * the GraphQL path and a host's direct service call from drifting apart.
+ *
+ * When no hook, listener or bridge is configured the runner passes through
+ * untouched.
  */
 exports.WmsMutationInterceptor = class WmsMutationInterceptor {
     reflector;
-    dispatcher;
+    runner;
     actorExtractor;
-    constructor(reflector, dispatcher, actorExtractor = null) {
+    constructor(reflector, runner, actorExtractor = null) {
         this.reflector = reflector;
-        this.dispatcher = dispatcher;
+        this.runner = runner;
         this.actorExtractor = actorExtractor;
     }
     resolveActor(context) {
@@ -411,34 +404,16 @@ exports.WmsMutationInterceptor = class WmsMutationInterceptor {
     }
     async intercept(context, next) {
         const config = this.reflector.get(WMS_MUTATION_EVENT_METADATA, context.getHandler());
-        if (!config || !this.dispatcher.isActive()) {
+        if (!config) {
             return next.handle();
         }
-        const args = graphql.GqlExecutionContext.create(context).getArgs() ??
-            {};
-        const actor = this.resolveActor(context);
-        // Before-hook runs before any DB work; a throw vetoes with zero side effects.
-        await this.dispatcher.runBeforeHook({
+        const result = await this.runner.run({
             event: config.event,
-            args,
+            args: graphql.GqlExecutionContext.create(context).getArgs() ?? {},
+            actor: this.resolveActor(context),
+            resolveId: config.resolveId,
             executionContext: context,
-            actor,
-        });
-        const { result, events } = await wmsModuleCore.runInDispatchScope(async () => {
-            const handlerResult = await rxjs.firstValueFrom(next.handle());
-            const id = config.resolveId
-                ? config.resolveId(handlerResult, args)
-                : defaultResolveId(handlerResult, args);
-            const operationEvent = {
-                name: config.event,
-                payload: { id, result: handlerResult, args, actor },
-            };
-            wmsModuleCore.collectToScope(operationEvent);
-            return handlerResult;
-        });
-        if (events) {
-            await this.dispatcher.flush(events);
-        }
+        }, () => rxjs.firstValueFrom(next.handle()));
         return rxjs.of(result);
     }
 };
@@ -447,7 +422,7 @@ exports.WmsMutationInterceptor = tslib.__decorate([
     tslib.__param(2, common.Optional()),
     tslib.__param(2, common.Inject(wmsModuleCore.WMS_ACTOR_EXTRACTOR)),
     tslib.__metadata("design:paramtypes", [core.Reflector,
-        wmsModuleCore.WmsEventDispatcher, Object])
+        wmsModuleCore.WmsOperationRunner, Object])
 ], exports.WmsMutationInterceptor);
 
 /**
@@ -822,6 +797,65 @@ MaterialUnits = tslib.__decorate([
     graphql.ObjectType()
 ], MaterialUnits);
 
+/**
+ * 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 graphql$1.Kind.STRING:
+        case graphql$1.Kind.BOOLEAN:
+            return node.value;
+        case graphql$1.Kind.INT:
+        case graphql$1.Kind.FLOAT:
+            return Number(node.value);
+        case graphql$1.Kind.NULL:
+            return null;
+        case graphql$1.Kind.LIST:
+            return node.values.map(parseLiteralValue);
+        case graphql$1.Kind.OBJECT:
+            return parseObjectLiteral(node);
+        default:
+            throw new graphql$1.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 graphql$1.GraphQLError('JSONObject must be a plain JSON object');
+    }
+    return value;
+}
+const GraphQLJSONObject = new graphql$1.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 !== graphql$1.Kind.OBJECT) {
+            throw new graphql$1.GraphQLError('JSONObject must be an object literal', {
+                nodes: node,
+            });
+        }
+        return parseObjectLiteral(node);
+    },
+});
+
 let StockDto = class StockDto {
     id;
     loaderId;
@@ -867,6 +901,21 @@ let AggregatedStockDto = class AggregatedStockDto {
     customerId;
     vendorId;
     inspectionResult;
+    /**
+     * Whether anyone asked for this batch to be inspected. Paired with
+     * `inspectionResult`, it is what separates "awaiting inspection" from
+     * "nobody ever intended to inspect this", which `inspectionResult` alone
+     * cannot say.
+     */
+    requiresInspection;
+    /**
+     * Batch lineage and the host's own attributes, flattened onto the row the way
+     * every other batch column here already is. `batch` resolves to the batch
+     * *group*, which is what carries the human-readable key — these two live on
+     * the batch itself and would otherwise be unreachable from a stock list.
+     */
+    parentBatchId;
+    attributes;
 };
 tslib.__decorate([
     graphql.Field(() => graphql.Int),
@@ -908,6 +957,18 @@ tslib.__decorate([
     graphql.Field(() => Boolean, { nullable: true }),
     tslib.__metadata("design:type", Boolean)
 ], AggregatedStockDto.prototype, "inspectionResult", void 0);
+tslib.__decorate([
+    graphql.Field(() => Boolean, { nullable: true }),
+    tslib.__metadata("design:type", Boolean)
+], AggregatedStockDto.prototype, "requiresInspection", void 0);
+tslib.__decorate([
+    graphql.Field(() => graphql.ID, { nullable: true }),
+    tslib.__metadata("design:type", Object)
+], AggregatedStockDto.prototype, "parentBatchId", void 0);
+tslib.__decorate([
+    graphql.Field(() => GraphQLJSONObject, { nullable: true }),
+    tslib.__metadata("design:type", Object)
+], AggregatedStockDto.prototype, "attributes", void 0);
 AggregatedStockDto = tslib.__decorate([
     graphql.ObjectType()
 ], AggregatedStockDto);
@@ -1767,8 +1828,14 @@ let InventoryCountOrderItemDto = class InventoryCountOrderItemDto {
     // a record of what was found. `null` before counting has started.
     held;
     inShipment;
-    /** `null` = awaiting inspection, `false` = failed, `true` = passed. */
+    /**
+     * `false` = failed, `true` = passed, `null` = not inspected — which is the
+     * resting state of almost every batch and does **not** on its own mean
+     * awaiting inspection. Pair it with `requiresInspection`.
+     */
     inspectionResult;
+    /** Whether anybody had asked for this position to be inspected. */
+    requiresInspection;
     transferId;
     vendorId;
     customerId;
@@ -1827,6 +1894,10 @@ tslib.__decorate([
     graphql.Field(() => Boolean, { nullable: true }),
     tslib.__metadata("design:type", Object)
 ], InventoryCountOrderItemDto.prototype, "inspectionResult", void 0);
+tslib.__decorate([
+    graphql.Field(() => Boolean, { nullable: true }),
+    tslib.__metadata("design:type", Object)
+], InventoryCountOrderItemDto.prototype, "requiresInspection", void 0);
 tslib.__decorate([
     graphql.Field(() => graphql.ID, { nullable: true }),
     tslib.__metadata("design:type", Object)
@@ -1925,6 +1996,156 @@ InventoryCountOrders = tslib.__decorate([
     graphql.ObjectType()
 ], InventoryCountOrders);
 
+let ConsumptionOrderItemDto = class ConsumptionOrderItemDto {
+    id;
+    materialId;
+    batchId;
+    locationId;
+    loaderId;
+    targetLocationId;
+    targetLoaderId;
+    orderId;
+    unitId;
+    targetConsumedQuantity;
+    removedAt;
+};
+tslib.__decorate([
+    graphql.Field(() => graphql.ID),
+    tslib.__metadata("design:type", String)
+], ConsumptionOrderItemDto.prototype, "id", void 0);
+tslib.__decorate([
+    graphql.Field(() => String, { nullable: true }),
+    tslib.__metadata("design:type", Object)
+], ConsumptionOrderItemDto.prototype, "unitId", void 0);
+tslib.__decorate([
+    graphql.Field(() => graphql.Float),
+    tslib.__metadata("design:type", Number)
+], ConsumptionOrderItemDto.prototype, "targetConsumedQuantity", void 0);
+tslib.__decorate([
+    graphql.Field(() => Date, { nullable: true }),
+    tslib.__metadata("design:type", Object)
+], ConsumptionOrderItemDto.prototype, "removedAt", void 0);
+ConsumptionOrderItemDto = tslib.__decorate([
+    graphql.ObjectType()
+], ConsumptionOrderItemDto);
+let ConsumptionOrderItems = class ConsumptionOrderItems extends PaginatedResponse(ConsumptionOrderItemDto) {
+};
+ConsumptionOrderItems = tslib.__decorate([
+    graphql.ObjectType()
+], ConsumptionOrderItems);
+
+let ConsumptionOrderDto = class ConsumptionOrderDto {
+    id;
+    key;
+    description;
+    createdBy;
+    removedAt;
+    createdAt;
+    items;
+};
+tslib.__decorate([
+    graphql.Field(() => graphql.ID),
+    tslib.__metadata("design:type", String)
+], ConsumptionOrderDto.prototype, "id", void 0);
+tslib.__decorate([
+    graphql.Field(() => String),
+    tslib.__metadata("design:type", String)
+], ConsumptionOrderDto.prototype, "key", void 0);
+tslib.__decorate([
+    graphql.Field(() => String, { nullable: true }),
+    tslib.__metadata("design:type", Object)
+], ConsumptionOrderDto.prototype, "description", void 0);
+tslib.__decorate([
+    graphql.Field(() => String, { nullable: true }),
+    tslib.__metadata("design:type", Object)
+], ConsumptionOrderDto.prototype, "createdBy", void 0);
+tslib.__decorate([
+    graphql.Field(() => Date, { nullable: true }),
+    tslib.__metadata("design:type", Object)
+], ConsumptionOrderDto.prototype, "removedAt", void 0);
+tslib.__decorate([
+    graphql.Field(() => Date),
+    tslib.__metadata("design:type", Date)
+], ConsumptionOrderDto.prototype, "createdAt", void 0);
+tslib.__decorate([
+    graphql.Field(() => [ConsumptionOrderItemDto]),
+    tslib.__metadata("design:type", Array)
+], ConsumptionOrderDto.prototype, "items", void 0);
+ConsumptionOrderDto = tslib.__decorate([
+    graphql.ObjectType()
+], ConsumptionOrderDto);
+let ConsumptionOrders = class ConsumptionOrders extends PaginatedResponse(ConsumptionOrderDto) {
+};
+ConsumptionOrders = tslib.__decorate([
+    graphql.ObjectType()
+], ConsumptionOrders);
+
+graphql.registerEnumType(wmsModuleCore.WmsOrderType, {
+    name: 'WmsOrderType',
+    description: 'An order family in this module, named the same way `@WmsOperation` names it.',
+});
+/**
+ * A link from one of this module's orders to the document in the host system it
+ * was opened for. The module stores `referenceType` / `referenceId` verbatim
+ * and never resolves them — turning one into a link is the host's job (see
+ * `referenceLinkResolver` in `@rytass/wms-module-react`).
+ */
+let OrderReferenceDto = class OrderReferenceDto {
+    id;
+    orderType;
+    orderId;
+    itemId;
+    referenceType;
+    referenceId;
+    referenceLine;
+    metadata;
+    createdAt;
+};
+tslib.__decorate([
+    graphql.Field(() => graphql.ID),
+    tslib.__metadata("design:type", String)
+], OrderReferenceDto.prototype, "id", void 0);
+tslib.__decorate([
+    graphql.Field(() => wmsModuleCore.WmsOrderType),
+    tslib.__metadata("design:type", String)
+], OrderReferenceDto.prototype, "orderType", void 0);
+tslib.__decorate([
+    graphql.Field(() => graphql.ID),
+    tslib.__metadata("design:type", String)
+], OrderReferenceDto.prototype, "orderId", void 0);
+tslib.__decorate([
+    graphql.Field(() => graphql.ID, { nullable: true }),
+    tslib.__metadata("design:type", Object)
+], OrderReferenceDto.prototype, "itemId", void 0);
+tslib.__decorate([
+    graphql.Field(() => String),
+    tslib.__metadata("design:type", String)
+], OrderReferenceDto.prototype, "referenceType", void 0);
+tslib.__decorate([
+    graphql.Field(() => String),
+    tslib.__metadata("design:type", String)
+], OrderReferenceDto.prototype, "referenceId", void 0);
+tslib.__decorate([
+    graphql.Field(() => String, { nullable: true }),
+    tslib.__metadata("design:type", Object)
+], OrderReferenceDto.prototype, "referenceLine", void 0);
+tslib.__decorate([
+    graphql.Field(() => GraphQLJSONObject, { nullable: true }),
+    tslib.__metadata("design:type", Object)
+], OrderReferenceDto.prototype, "metadata", void 0);
+tslib.__decorate([
+    graphql.Field(() => Date),
+    tslib.__metadata("design:type", Date)
+], OrderReferenceDto.prototype, "createdAt", void 0);
+OrderReferenceDto = tslib.__decorate([
+    graphql.ObjectType()
+], OrderReferenceDto);
+let OrderReferences = class OrderReferences extends PaginatedResponse(OrderReferenceDto) {
+};
+OrderReferences = tslib.__decorate([
+    graphql.ObjectType()
+], OrderReferences);
+
 let CreateLoaderTypeArgs = class CreateLoaderTypeArgs {
     description;
     key;
@@ -2351,9 +2572,7 @@ let LoaderQuery = class LoaderQuery {
                 if (loader.locationId === locationId)
                     loaders.push(loader);
             });
-        const [aggregatedStocks] = await this.stockService.findAggregatedStocks({
-            aggregated: true,
-        });
+        const [aggregatedStocks] = await this.stockService.findAggregatedStocks({});
         // Collect loaderIds that currently have stock
         const loaderIdsWithStock = new Set(aggregatedStocks.map((s) => s.loaderId).filter(Boolean));
         // Find targetLoaderIds booked in not-yet-executed transfer order items
@@ -2599,6 +2818,12 @@ let FindStockArgs = class FindStockArgs extends PaginationArgs {
     materialId;
     batchId;
     locationId;
+    /**
+     * Locations to leave out of the result. Subtractive counterpart to
+     * `locationId`: a stock report uses it to drop locations that do not hold
+     * available inventory (staging, quarantine, a host's work-in-progress lane).
+     */
+    excludeLocationIds;
     loaderId;
     ids;
     description;
@@ -2629,6 +2854,10 @@ tslib.__decorate([
     graphql.Field(() => graphql.ID, { nullable: true }),
     tslib.__metadata("design:type", String)
 ], FindStockArgs.prototype, "locationId", void 0);
+tslib.__decorate([
+    graphql.Field(() => [graphql.ID], { nullable: true }),
+    tslib.__metadata("design:type", Array)
+], FindStockArgs.prototype, "excludeLocationIds", void 0);
 tslib.__decorate([
     graphql.Field(() => graphql.ID, { nullable: true }),
     tslib.__metadata("design:type", String)
@@ -2700,16 +2929,12 @@ let StockQuery = class StockQuery {
     async aggregatedStocks(args) {
         const [items, total] = await this.stockService.findAggregatedStocks({
             ...args,
-            aggregated: true,
             aggregatedKeys: args.ids?.length ? args.ids : [],
         });
         return { items, total };
     }
     async changeLogs(args) {
-        const [items, total] = await this.stockService.findChangeLogs({
-            ...args,
-            aggregated: false,
-        });
+        const [items, total] = await this.stockService.findChangeLogs(args);
         return {
             items: items.map((item) => ({
                 ...item,
@@ -3512,7 +3737,6 @@ let LoaderResolver = class LoaderResolver {
     async totalQuantity({ id }) {
         const [aggregatedStocks] = await this.stockService.findAggregatedStocks({
             loaderId: id,
-            aggregated: true,
         });
         if (!aggregatedStocks.length)
             return 0;
@@ -3573,7 +3797,6 @@ let MaterialResolver = class MaterialResolver {
         // TODO: should be compatible with dataloader in the future
         const [items] = await this.stockService.findAggregatedStocks({
             materialId: id,
-            aggregated: true,
         });
         return items;
     }
@@ -5192,65 +5415,723 @@ BatchQuery = tslib.__decorate([
     tslib.__metadata("design:paramtypes", [wmsModuleCore.BatchService])
 ], BatchQuery);
 
-let ChangeLogResolver = class ChangeLogResolver {
-    entities;
-    /**
-     * The configured entities, not the built-in classes: `__entity` decides which
-     * repository the DataLoader opens, so it has to follow whatever the consumer
-     * passed to `WMSBaseModuleOptions`. Loading a built-in class outright filters
-     * on its single-table-inheritance discriminator and resolves nothing for an
-     * override.
-     */
-    constructor(entities) {
-        this.entities = entities;
-    }
-    material({ materialId }, { loaders }) {
-        return loaders.batchSingle.load({
-            __entity: this.entities.material,
-            __from: { id: materialId },
-        });
-    }
-    location({ locationId }, { loaders }) {
-        return loaders.batchSingle.load({
-            __entity: this.entities.location,
-            __from: { id: locationId },
-        });
+/**
+ * Reads the link in either direction: give it an order to list what that order
+ * was opened for, or a `referenceType` / `referenceId` to list every order
+ * opened for that document.
+ *
+ * `referenceType` / `referenceId` / `referenceLine` match exactly, never as a
+ * substring — they are identifiers the host owns, and a partial match on
+ * 「WO-1」 would quietly sweep in 「WO-10」.
+ */
+let FindOrderReferenceArgs = class FindOrderReferenceArgs extends PaginationArgs {
+    orderType;
+    orderId;
+    itemId;
+    referenceType;
+    referenceId;
+    referenceLine;
+};
+tslib.__decorate([
+    graphql.Field(() => wmsModuleCore.WmsOrderType, { nullable: true }),
+    tslib.__metadata("design:type", String)
+], FindOrderReferenceArgs.prototype, "orderType", void 0);
+tslib.__decorate([
+    graphql.Field(() => graphql.ID, { nullable: true }),
+    tslib.__metadata("design:type", String)
+], FindOrderReferenceArgs.prototype, "orderId", void 0);
+tslib.__decorate([
+    graphql.Field(() => graphql.ID, { nullable: true }),
+    tslib.__metadata("design:type", String)
+], FindOrderReferenceArgs.prototype, "itemId", void 0);
+tslib.__decorate([
+    graphql.Field(() => String, { nullable: true }),
+    tslib.__metadata("design:type", String)
+], FindOrderReferenceArgs.prototype, "referenceType", void 0);
+tslib.__decorate([
+    graphql.Field(() => String, { nullable: true }),
+    tslib.__metadata("design:type", String)
+], FindOrderReferenceArgs.prototype, "referenceId", void 0);
+tslib.__decorate([
+    graphql.Field(() => String, { nullable: true }),
+    tslib.__metadata("design:type", String)
+], FindOrderReferenceArgs.prototype, "referenceLine", void 0);
+FindOrderReferenceArgs = tslib.__decorate([
+    graphql.ArgsType()
+], FindOrderReferenceArgs);
+let OrderReferenceInputType = class OrderReferenceInputType {
+    referenceType;
+    referenceId;
+    referenceLine;
+    /** The order item this link is about; omit for an order-level link. */
+    itemId;
+    metadata;
+};
+tslib.__decorate([
+    graphql.Field(() => String),
+    tslib.__metadata("design:type", String)
+], OrderReferenceInputType.prototype, "referenceType", void 0);
+tslib.__decorate([
+    graphql.Field(() => String),
+    tslib.__metadata("design:type", String)
+], OrderReferenceInputType.prototype, "referenceId", void 0);
+tslib.__decorate([
+    graphql.Field(() => String, { nullable: true }),
+    tslib.__metadata("design:type", Object)
+], OrderReferenceInputType.prototype, "referenceLine", void 0);
+tslib.__decorate([
+    graphql.Field(() => graphql.ID, { nullable: true }),
+    tslib.__metadata("design:type", Object)
+], OrderReferenceInputType.prototype, "itemId", void 0);
+tslib.__decorate([
+    graphql.Field(() => GraphQLJSONObject, { nullable: true }),
+    tslib.__metadata("design:type", Object)
+], OrderReferenceInputType.prototype, "metadata", void 0);
+OrderReferenceInputType = tslib.__decorate([
+    graphql.InputType()
+], OrderReferenceInputType);
+let AttachOrderReferencesArgs = class AttachOrderReferencesArgs {
+    orderType;
+    orderId;
+    references;
+};
+tslib.__decorate([
+    graphql.Field(() => wmsModuleCore.WmsOrderType),
+    tslib.__metadata("design:type", String)
+], AttachOrderReferencesArgs.prototype, "orderType", void 0);
+tslib.__decorate([
+    graphql.Field(() => graphql.ID),
+    tslib.__metadata("design:type", String)
+], AttachOrderReferencesArgs.prototype, "orderId", void 0);
+tslib.__decorate([
+    graphql.Field(() => [OrderReferenceInputType]),
+    tslib.__metadata("design:type", Array)
+], AttachOrderReferencesArgs.prototype, "references", void 0);
+AttachOrderReferencesArgs = tslib.__decorate([
+    graphql.ArgsType()
+], AttachOrderReferencesArgs);
+
+let OrderReferenceQuery = class OrderReferenceQuery {
+    orderReferenceService;
+    constructor(orderReferenceService) {
+        this.orderReferenceService = orderReferenceService;
     }
-    async batch({ batchId }, { loaders }) {
-        const { groupId } = await loaders.batchSingle.load({
-            __entity: this.entities.batch,
-            __from: { id: batchId },
-        });
-        return loaders.batchSingle.load({
-            __entity: wmsModuleCore.BatchGroupEntityClass,
-            __from: { id: groupId },
-        });
+    async orderReferences(args) {
+        const [items, total] = await this.orderReferenceService.findMany(args);
+        return { items, total };
     }
 };
 tslib.__decorate([
-    graphql.ResolveField(() => MaterialDto),
-    tslib.__param(0, graphql.Parent()),
-    tslib.__param(1, graphql.Context()),
+    graphql.Query(() => OrderReferences),
+    WmsOperation({ resource: 'order-reference', action: 'read' }),
+    tslib.__param(0, graphql.Args()),
     tslib.__metadata("design:type", Function),
-    tslib.__metadata("design:paramtypes", [wmsModuleCore.StockEntityClass, Object]),
+    tslib.__metadata("design:paramtypes", [FindOrderReferenceArgs]),
     tslib.__metadata("design:returntype", Promise)
-], ChangeLogResolver.prototype, "material", null);
+], OrderReferenceQuery.prototype, "orderReferences", null);
+OrderReferenceQuery = tslib.__decorate([
+    common.Injectable(),
+    graphql.Resolver(),
+    tslib.__metadata("design:paramtypes", [wmsModuleCore.OrderReferenceService])
+], OrderReferenceQuery);
+
+let OrderReferenceMutation = class OrderReferenceMutation {
+    orderReferenceService;
+    constructor(orderReferenceService) {
+        this.orderReferenceService = orderReferenceService;
+    }
+    /**
+     * Additive: attaching twice leaves both sets in place. Detach the ones that
+     * no longer apply rather than expecting this to replace them.
+     */
+    attachOrderReferences(args) {
+        return this.orderReferenceService.attach({
+            orderType: args.orderType,
+            orderId: args.orderId,
+            references: args.references,
+        });
+    }
+    async detachOrderReference(id) {
+        await this.orderReferenceService.detach(id);
+        return true;
+    }
+};
 tslib.__decorate([
-    graphql.ResolveField(() => LocationDto),
-    tslib.__param(0, graphql.Parent()),
-    tslib.__param(1, graphql.Context()),
+    graphql.Mutation(() => [OrderReferenceDto]),
+    WmsOperation({ resource: 'order-reference', action: 'attach' }),
+    WmsMutationEvent({ event: 'order-reference.attached' }),
+    tslib.__param(0, graphql.Args()),
     tslib.__metadata("design:type", Function),
-    tslib.__metadata("design:paramtypes", [wmsModuleCore.StockEntityClass, Object]),
+    tslib.__metadata("design:paramtypes", [AttachOrderReferencesArgs]),
     tslib.__metadata("design:returntype", Promise)
-], ChangeLogResolver.prototype, "location", null);
+], OrderReferenceMutation.prototype, "attachOrderReferences", null);
 tslib.__decorate([
-    graphql.ResolveField(() => BatchDto),
-    tslib.__param(0, graphql.Parent()),
-    tslib.__param(1, graphql.Context()),
+    graphql.Mutation(() => Boolean),
+    WmsOperation({ resource: 'order-reference', action: 'detach' }),
+    WmsMutationEvent({ event: 'order-reference.detached' }),
+    tslib.__param(0, graphql.Args('id', { type: () => graphql.ID })),
     tslib.__metadata("design:type", Function),
-    tslib.__metadata("design:paramtypes", [wmsModuleCore.StockEntityClass, Object]),
+    tslib.__metadata("design:paramtypes", [String]),
     tslib.__metadata("design:returntype", Promise)
-], ChangeLogResolver.prototype, "batch", null);
+], OrderReferenceMutation.prototype, "detachOrderReference", null);
+OrderReferenceMutation = tslib.__decorate([
+    common.Injectable(),
+    graphql.Resolver(),
+    tslib.__metadata("design:paramtypes", [wmsModuleCore.OrderReferenceService])
+], OrderReferenceMutation);
+
+let CreateConsumptionOrderItemInputType = class CreateConsumptionOrderItemInputType {
+    materialId;
+    batchId;
+    /** Where the material is issued from. Defaults to the module's default location. */
+    locationId;
+    loaderId;
+    unitId;
+    quantity;
+    /** Where it sits while the process holds it. Defaults to the source location. */
+    targetLocationId;
+    targetLoaderId;
+};
+tslib.__decorate([
+    graphql.Field(() => graphql.ID),
+    tslib.__metadata("design:type", String)
+], CreateConsumptionOrderItemInputType.prototype, "materialId", void 0);
+tslib.__decorate([
+    graphql.Field(() => graphql.ID),
+    tslib.__metadata("design:type", String)
+], CreateConsumptionOrderItemInputType.prototype, "batchId", void 0);
+tslib.__decorate([
+    graphql.Field(() => graphql.ID, { nullable: true }),
+    tslib.__metadata("design:type", String)
+], CreateConsumptionOrderItemInputType.prototype, "locationId", void 0);
+tslib.__decorate([
+    graphql.Field(() => graphql.ID, { nullable: true }),
+    tslib.__metadata("design:type", String)
+], CreateConsumptionOrderItemInputType.prototype, "loaderId", void 0);
+tslib.__decorate([
+    graphql.Field(() => graphql.ID, { nullable: true }),
+    tslib.__metadata("design:type", String)
+], CreateConsumptionOrderItemInputType.prototype, "unitId", void 0);
+tslib.__decorate([
+    graphql.Field(() => graphql.Float),
+    tslib.__metadata("design:type", Number)
+], CreateConsumptionOrderItemInputType.prototype, "quantity", void 0);
+tslib.__decorate([
+    graphql.Field(() => graphql.ID, { nullable: true }),
+    tslib.__metadata("design:type", String)
+], CreateConsumptionOrderItemInputType.prototype, "targetLocationId", void 0);
+tslib.__decorate([
+    graphql.Field(() => graphql.ID, { nullable: true }),
+    tslib.__metadata("design:type", String)
+], CreateConsumptionOrderItemInputType.prototype, "targetLoaderId", void 0);
+CreateConsumptionOrderItemInputType = tslib.__decorate([
+    graphql.InputType()
+], CreateConsumptionOrderItemInputType);
+let CreateConsumptionOrderArgs = class CreateConsumptionOrderArgs {
+    description;
+    createdBy;
+    items;
+};
+tslib.__decorate([
+    graphql.Field(() => String, { nullable: true }),
+    tslib.__metadata("design:type", String)
+], CreateConsumptionOrderArgs.prototype, "description", void 0);
+tslib.__decorate([
+    graphql.Field(() => String, { nullable: true }),
+    tslib.__metadata("design:type", String)
+], CreateConsumptionOrderArgs.prototype, "createdBy", void 0);
+tslib.__decorate([
+    graphql.Field(() => [CreateConsumptionOrderItemInputType]),
+    tslib.__metadata("design:type", Array)
+], CreateConsumptionOrderArgs.prototype, "items", void 0);
+CreateConsumptionOrderArgs = tslib.__decorate([
+    graphql.ArgsType()
+], CreateConsumptionOrderArgs);
+let UpdateConsumptionOrderArgs = class UpdateConsumptionOrderArgs {
+    id;
+    description;
+    /** Replaces every line. Refused once the order has moved any stock. */
+    items;
+};
+tslib.__decorate([
+    graphql.Field(() => graphql.ID),
+    tslib.__metadata("design:type", String)
+], UpdateConsumptionOrderArgs.prototype, "id", void 0);
+tslib.__decorate([
+    graphql.Field(() => String, { nullable: true }),
+    tslib.__metadata("design:type", String)
+], UpdateConsumptionOrderArgs.prototype, "description", void 0);
+tslib.__decorate([
+    graphql.Field(() => [CreateConsumptionOrderItemInputType], { nullable: true }),
+    tslib.__metadata("design:type", Array)
+], UpdateConsumptionOrderArgs.prototype, "items", void 0);
+UpdateConsumptionOrderArgs = tslib.__decorate([
+    graphql.ArgsType()
+], UpdateConsumptionOrderArgs);
+let ConsumptionOrderLineInputType = class ConsumptionOrderLineInputType {
+    itemId;
+    /** Omit for whatever is outstanding on that line. */
+    quantity;
+};
+tslib.__decorate([
+    graphql.Field(() => graphql.ID),
+    tslib.__metadata("design:type", String)
+], ConsumptionOrderLineInputType.prototype, "itemId", void 0);
+tslib.__decorate([
+    graphql.Field(() => graphql.Float, { nullable: true }),
+    tslib.__metadata("design:type", Number)
+], ConsumptionOrderLineInputType.prototype, "quantity", void 0);
+ConsumptionOrderLineInputType = tslib.__decorate([
+    graphql.InputType()
+], ConsumptionOrderLineInputType);
+let ConsumptionOrderActionArgs = class ConsumptionOrderActionArgs {
+    orderId;
+    /** Omit to act on every line of the order. */
+    items;
+};
+tslib.__decorate([
+    graphql.Field(() => graphql.ID),
+    tslib.__metadata("design:type", String)
+], ConsumptionOrderActionArgs.prototype, "orderId", void 0);
+tslib.__decorate([
+    graphql.Field(() => [ConsumptionOrderLineInputType], { nullable: true }),
+    tslib.__metadata("design:type", Array)
+], ConsumptionOrderActionArgs.prototype, "items", void 0);
+ConsumptionOrderActionArgs = tslib.__decorate([
+    graphql.ArgsType()
+], ConsumptionOrderActionArgs);
+let FindConsumptionOrderArgs = class FindConsumptionOrderArgs extends PaginationArgs {
+    ids;
+    key;
+    description;
+    materialId;
+    batchId;
+    /** Matches either the source or the consuming location. */
+    locationId;
+    createdBy;
+    createdAtFrom;
+    createdAtTo;
+    includeRemoved;
+};
+tslib.__decorate([
+    graphql.Field(() => [graphql.ID], { nullable: true }),
+    tslib.__metadata("design:type", Array)
+], FindConsumptionOrderArgs.prototype, "ids", void 0);
+tslib.__decorate([
+    graphql.Field(() => String, { nullable: true }),
+    tslib.__metadata("design:type", String)
+], FindConsumptionOrderArgs.prototype, "key", void 0);
+tslib.__decorate([
+    graphql.Field(() => String, { nullable: true }),
+    tslib.__metadata("design:type", String)
+], FindConsumptionOrderArgs.prototype, "description", void 0);
+tslib.__decorate([
+    graphql.Field(() => graphql.ID, { nullable: true }),
+    tslib.__metadata("design:type", String)
+], FindConsumptionOrderArgs.prototype, "materialId", void 0);
+tslib.__decorate([
+    graphql.Field(() => graphql.ID, { nullable: true }),
+    tslib.__metadata("design:type", String)
+], FindConsumptionOrderArgs.prototype, "batchId", void 0);
+tslib.__decorate([
+    graphql.Field(() => graphql.ID, { nullable: true }),
+    tslib.__metadata("design:type", String)
+], FindConsumptionOrderArgs.prototype, "locationId", void 0);
+tslib.__decorate([
+    graphql.Field(() => String, { nullable: true }),
+    tslib.__metadata("design:type", String)
+], FindConsumptionOrderArgs.prototype, "createdBy", void 0);
+tslib.__decorate([
+    graphql.Field(() => Date, { nullable: true }),
+    tslib.__metadata("design:type", Date)
+], FindConsumptionOrderArgs.prototype, "createdAtFrom", void 0);
+tslib.__decorate([
+    graphql.Field(() => Date, { nullable: true }),
+    tslib.__metadata("design:type", Date)
+], FindConsumptionOrderArgs.prototype, "createdAtTo", void 0);
+tslib.__decorate([
+    graphql.Field(() => Boolean, { nullable: true }),
+    tslib.__metadata("design:type", Boolean)
+], FindConsumptionOrderArgs.prototype, "includeRemoved", void 0);
+FindConsumptionOrderArgs = tslib.__decorate([
+    graphql.ArgsType()
+], FindConsumptionOrderArgs);
+
+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 };
+    }
+};
+tslib.__decorate([
+    graphql.Query(() => ConsumptionOrderDto),
+    WmsOperation({ resource: 'consumption-order', action: 'read' }),
+    tslib.__param(0, graphql.Args('id', { type: () => graphql.ID })),
+    tslib.__metadata("design:type", Function),
+    tslib.__metadata("design:paramtypes", [String]),
+    tslib.__metadata("design:returntype", Promise)
+], ConsumptionOrderQuery.prototype, "consumptionOrder", null);
+tslib.__decorate([
+    graphql.Query(() => ConsumptionOrders),
+    WmsOperation({ resource: 'consumption-order', action: 'read' }),
+    tslib.__param(0, graphql.Args()),
+    tslib.__metadata("design:type", Function),
+    tslib.__metadata("design:paramtypes", [FindConsumptionOrderArgs]),
+    tslib.__metadata("design:returntype", Promise)
+], ConsumptionOrderQuery.prototype, "consumptionOrders", null);
+ConsumptionOrderQuery = tslib.__decorate([
+    common.Injectable(),
+    graphql.Resolver(),
+    tslib.__metadata("design:paramtypes", [wmsModuleCore.ConsumptionOrderService])
+], ConsumptionOrderQuery);
+
+/**
+ * The three actions are separate mutations rather than one with a mode
+ * argument: they carry different permissions (a host may well let the floor
+ * issue and return but not settle) and different events, and both of those are
+ * keyed per field.
+ */
+let ConsumptionOrderMutation = class ConsumptionOrderMutation {
+    consumptionOrderService;
+    constructor(consumptionOrderService) {
+        this.consumptionOrderService = consumptionOrderService;
+    }
+    createConsumptionOrder(args) {
+        return this.consumptionOrderService.createConsumptionOrder(args);
+    }
+    updateConsumptionOrder(args) {
+        return this.consumptionOrderService.updateConsumptionOrder(args);
+    }
+    issueConsumptionOrder(args) {
+        return this.consumptionOrderService.issue(args);
+    }
+    returnConsumptionOrder(args) {
+        return this.consumptionOrderService.return(args);
+    }
+    settleConsumptionOrder(args) {
+        return this.consumptionOrderService.settle(args);
+    }
+};
+tslib.__decorate([
+    graphql.Mutation(() => ConsumptionOrderDto),
+    WmsOperation({ resource: 'consumption-order', action: 'create' }),
+    WmsMutationEvent({ event: 'consumption-order.created' }),
+    tslib.__param(0, graphql.Args()),
+    tslib.__metadata("design:type", Function),
+    tslib.__metadata("design:paramtypes", [CreateConsumptionOrderArgs]),
+    tslib.__metadata("design:returntype", Promise)
+], ConsumptionOrderMutation.prototype, "createConsumptionOrder", null);
+tslib.__decorate([
+    graphql.Mutation(() => ConsumptionOrderDto),
+    WmsOperation({ resource: 'consumption-order', action: 'update' }),
+    WmsMutationEvent({ event: 'consumption-order.updated' }),
+    tslib.__param(0, graphql.Args()),
+    tslib.__metadata("design:type", Function),
+    tslib.__metadata("design:paramtypes", [UpdateConsumptionOrderArgs]),
+    tslib.__metadata("design:returntype", Promise)
+], ConsumptionOrderMutation.prototype, "updateConsumptionOrder", null);
+tslib.__decorate([
+    graphql.Mutation(() => Boolean),
+    WmsOperation({ resource: 'consumption-order', action: 'issue' }),
+    WmsMutationEvent({ event: 'consumption-order.issued' }),
+    tslib.__param(0, graphql.Args()),
+    tslib.__metadata("design:type", Function),
+    tslib.__metadata("design:paramtypes", [ConsumptionOrderActionArgs]),
+    tslib.__metadata("design:returntype", Promise)
+], ConsumptionOrderMutation.prototype, "issueConsumptionOrder", null);
+tslib.__decorate([
+    graphql.Mutation(() => Boolean),
+    WmsOperation({ resource: 'consumption-order', action: 'return' }),
+    WmsMutationEvent({ event: 'consumption-order.returned' }),
+    tslib.__param(0, graphql.Args()),
+    tslib.__metadata("design:type", Function),
+    tslib.__metadata("design:paramtypes", [ConsumptionOrderActionArgs]),
+    tslib.__metadata("design:returntype", Promise)
+], ConsumptionOrderMutation.prototype, "returnConsumptionOrder", null);
+tslib.__decorate([
+    graphql.Mutation(() => Boolean),
+    WmsOperation({ resource: 'consumption-order', action: 'settle' }),
+    WmsMutationEvent({ event: 'consumption-order.settled' }),
+    tslib.__param(0, graphql.Args()),
+    tslib.__metadata("design:type", Function),
+    tslib.__metadata("design:paramtypes", [ConsumptionOrderActionArgs]),
+    tslib.__metadata("design:returntype", Promise)
+], ConsumptionOrderMutation.prototype, "settleConsumptionOrder", null);
+ConsumptionOrderMutation = tslib.__decorate([
+    common.Injectable(),
+    graphql.Resolver(),
+    tslib.__metadata("design:paramtypes", [wmsModuleCore.ConsumptionOrderService])
+], ConsumptionOrderMutation);
+
+let ConsumptionOrderResolver = class ConsumptionOrderResolver {
+    items({ id }, { loaders }) {
+        return loaders.batchMany.load({
+            __entity: wmsModuleCore.ConsumptionOrderItemEntityClass,
+            __from: { orderId: id },
+        });
+    }
+};
+tslib.__decorate([
+    graphql.ResolveField(() => [ConsumptionOrderItemDto]),
+    tslib.__param(0, graphql.Parent()),
+    tslib.__param(1, graphql.Context()),
+    tslib.__metadata("design:type", Function),
+    tslib.__metadata("design:paramtypes", [ConsumptionOrderDto, Object]),
+    tslib.__metadata("design:returntype", Promise)
+], ConsumptionOrderResolver.prototype, "items", null);
+ConsumptionOrderResolver = tslib.__decorate([
+    graphql.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: wmsModuleCore.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: wmsModuleCore.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: wmsModuleCore.LoadersEntityClass,
+            __from: { id: loaderId },
+        });
+    }
+    async targetLoader({ targetLoaderId }, { loaders }) {
+        if (!targetLoaderId)
+            return null;
+        return loaders.batchSingle.load({
+            __entity: wmsModuleCore.LoadersEntityClass,
+            __from: { id: targetLoaderId },
+        });
+    }
+    issuedQuantity({ id }, { loaders }) {
+        return this.movedQuantity(id, wmsModuleCore.ConsumptionChangeKind.ISSUE, loaders);
+    }
+    returnedQuantity({ id }, { loaders }) {
+        return this.movedQuantity(id, wmsModuleCore.ConsumptionChangeKind.RETURN, loaders);
+    }
+    settledQuantity({ id }, { loaders }) {
+        return this.movedQuantity(id, wmsModuleCore.ConsumptionChangeKind.SETTLE, loaders);
+    }
+    /** Issued minus returned minus settled: what the process still holds. */
+    async outstandingQuantity({ id }, { loaders }) {
+        const changes = await loaders.batchMany.load({
+            __entity: wmsModuleCore.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);
+    }
+};
+tslib.__decorate([
+    graphql.ResolveField(() => MaterialDto),
+    tslib.__param(0, graphql.Parent()),
+    tslib.__param(1, graphql.Context()),
+    tslib.__metadata("design:type", Function),
+    tslib.__metadata("design:paramtypes", [wmsModuleCore.ConsumptionOrderItemEntityClass, Object]),
+    tslib.__metadata("design:returntype", Promise)
+], ConsumptionOrderItemResolver.prototype, "material", null);
+tslib.__decorate([
+    graphql.ResolveField(() => BatchDto, { nullable: true }),
+    tslib.__param(0, graphql.Parent()),
+    tslib.__param(1, graphql.Context()),
+    tslib.__metadata("design:type", Function),
+    tslib.__metadata("design:paramtypes", [wmsModuleCore.ConsumptionOrderItemEntityClass, Object]),
+    tslib.__metadata("design:returntype", Promise)
+], ConsumptionOrderItemResolver.prototype, "batch", null);
+tslib.__decorate([
+    graphql.ResolveField(() => LocationDto, { nullable: true }),
+    tslib.__param(0, graphql.Parent()),
+    tslib.__param(1, graphql.Context()),
+    tslib.__metadata("design:type", Function),
+    tslib.__metadata("design:paramtypes", [wmsModuleCore.ConsumptionOrderItemEntityClass, Object]),
+    tslib.__metadata("design:returntype", Promise)
+], ConsumptionOrderItemResolver.prototype, "location", null);
+tslib.__decorate([
+    graphql.ResolveField(() => LocationDto, { nullable: true }),
+    tslib.__param(0, graphql.Parent()),
+    tslib.__param(1, graphql.Context()),
+    tslib.__metadata("design:type", Function),
+    tslib.__metadata("design:paramtypes", [wmsModuleCore.ConsumptionOrderItemEntityClass, Object]),
+    tslib.__metadata("design:returntype", Promise)
+], ConsumptionOrderItemResolver.prototype, "targetLocation", null);
+tslib.__decorate([
+    graphql.ResolveField(() => LoaderDto, { nullable: true }),
+    tslib.__param(0, graphql.Parent()),
+    tslib.__param(1, graphql.Context()),
+    tslib.__metadata("design:type", Function),
+    tslib.__metadata("design:paramtypes", [wmsModuleCore.ConsumptionOrderItemEntityClass, Object]),
+    tslib.__metadata("design:returntype", Promise)
+], ConsumptionOrderItemResolver.prototype, "loader", null);
+tslib.__decorate([
+    graphql.ResolveField(() => LoaderDto, { nullable: true }),
+    tslib.__param(0, graphql.Parent()),
+    tslib.__param(1, graphql.Context()),
+    tslib.__metadata("design:type", Function),
+    tslib.__metadata("design:paramtypes", [wmsModuleCore.ConsumptionOrderItemEntityClass, Object]),
+    tslib.__metadata("design:returntype", Promise)
+], ConsumptionOrderItemResolver.prototype, "targetLoader", null);
+tslib.__decorate([
+    graphql.ResolveField(() => graphql.Float),
+    tslib.__param(0, graphql.Parent()),
+    tslib.__param(1, graphql.Context()),
+    tslib.__metadata("design:type", Function),
+    tslib.__metadata("design:paramtypes", [wmsModuleCore.ConsumptionOrderItemEntityClass, Object]),
+    tslib.__metadata("design:returntype", Promise)
+], ConsumptionOrderItemResolver.prototype, "issuedQuantity", null);
+tslib.__decorate([
+    graphql.ResolveField(() => graphql.Float),
+    tslib.__param(0, graphql.Parent()),
+    tslib.__param(1, graphql.Context()),
+    tslib.__metadata("design:type", Function),
+    tslib.__metadata("design:paramtypes", [wmsModuleCore.ConsumptionOrderItemEntityClass, Object]),
+    tslib.__metadata("design:returntype", Promise)
+], ConsumptionOrderItemResolver.prototype, "returnedQuantity", null);
+tslib.__decorate([
+    graphql.ResolveField(() => graphql.Float),
+    tslib.__param(0, graphql.Parent()),
+    tslib.__param(1, graphql.Context()),
+    tslib.__metadata("design:type", Function),
+    tslib.__metadata("design:paramtypes", [wmsModuleCore.ConsumptionOrderItemEntityClass, Object]),
+    tslib.__metadata("design:returntype", Promise)
+], ConsumptionOrderItemResolver.prototype, "settledQuantity", null);
+tslib.__decorate([
+    graphql.ResolveField(() => graphql.Float),
+    tslib.__param(0, graphql.Parent()),
+    tslib.__param(1, graphql.Context()),
+    tslib.__metadata("design:type", Function),
+    tslib.__metadata("design:paramtypes", [wmsModuleCore.ConsumptionOrderItemEntityClass, Object]),
+    tslib.__metadata("design:returntype", Promise)
+], ConsumptionOrderItemResolver.prototype, "outstandingQuantity", null);
+ConsumptionOrderItemResolver = tslib.__decorate([
+    graphql.Resolver(() => ConsumptionOrderItemDto),
+    tslib.__metadata("design:paramtypes", [wmsModuleCore.WmsEntities])
+], ConsumptionOrderItemResolver);
+
+let ChangeLogResolver = class ChangeLogResolver {
+    entities;
+    /**
+     * The configured entities, not the built-in classes: `__entity` decides which
+     * repository the DataLoader opens, so it has to follow whatever the consumer
+     * passed to `WMSBaseModuleOptions`. Loading a built-in class outright filters
+     * on its single-table-inheritance discriminator and resolves nothing for an
+     * override.
+     */
+    constructor(entities) {
+        this.entities = entities;
+    }
+    material({ materialId }, { loaders }) {
+        return loaders.batchSingle.load({
+            __entity: this.entities.material,
+            __from: { id: materialId },
+        });
+    }
+    location({ locationId }, { loaders }) {
+        return loaders.batchSingle.load({
+            __entity: this.entities.location,
+            __from: { id: locationId },
+        });
+    }
+    async batch({ batchId }, { loaders }) {
+        const { groupId } = await loaders.batchSingle.load({
+            __entity: this.entities.batch,
+            __from: { id: batchId },
+        });
+        return loaders.batchSingle.load({
+            __entity: wmsModuleCore.BatchGroupEntityClass,
+            __from: { id: groupId },
+        });
+    }
+};
+tslib.__decorate([
+    graphql.ResolveField(() => MaterialDto),
+    tslib.__param(0, graphql.Parent()),
+    tslib.__param(1, graphql.Context()),
+    tslib.__metadata("design:type", Function),
+    tslib.__metadata("design:paramtypes", [wmsModuleCore.StockEntityClass, Object]),
+    tslib.__metadata("design:returntype", Promise)
+], ChangeLogResolver.prototype, "material", null);
+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.StockEntityClass, Object]),
+    tslib.__metadata("design:returntype", Promise)
+], ChangeLogResolver.prototype, "location", null);
+tslib.__decorate([
+    graphql.ResolveField(() => BatchDto),
+    tslib.__param(0, graphql.Parent()),
+    tslib.__param(1, graphql.Context()),
+    tslib.__metadata("design:type", Function),
+    tslib.__metadata("design:paramtypes", [wmsModuleCore.StockEntityClass, Object]),
+    tslib.__metadata("design:returntype", Promise)
+], ChangeLogResolver.prototype, "batch", null);
 ChangeLogResolver = tslib.__decorate([
     graphql.Resolver(() => ChangeLogDto),
     tslib.__metadata("design:paramtypes", [wmsModuleCore.WmsEntities])
@@ -6003,6 +6884,12 @@ SaleOrderQuery = tslib.__decorate([
 let SplitBatchItemInput = class SplitBatchItemInput {
     batchKey;
     quantity;
+    /**
+     * Host-defined attributes for this child batch. Applied only when the split
+     * creates the batch; reusing an existing `batchKey` keeps what that batch
+     * already carries.
+     */
+    attributes;
 };
 tslib.__decorate([
     graphql.Field(() => graphql.ID),
@@ -6012,6 +6899,10 @@ tslib.__decorate([
     graphql.Field(() => Number),
     tslib.__metadata("design:type", Number)
 ], SplitBatchItemInput.prototype, "quantity", void 0);
+tslib.__decorate([
+    graphql.Field(() => GraphQLJSONObject, { nullable: true }),
+    tslib.__metadata("design:type", Object)
+], SplitBatchItemInput.prototype, "attributes", void 0);
 SplitBatchItemInput = tslib.__decorate([
     graphql.InputType()
 ], SplitBatchItemInput);
@@ -7652,6 +8543,12 @@ const exportDependencies = [
     InventoryCountOrderMutation,
     InventoryCountOrderResolver,
     InventoryCountOrderItemResolver,
+    OrderReferenceQuery,
+    OrderReferenceMutation,
+    ConsumptionOrderQuery,
+    ConsumptionOrderMutation,
+    ConsumptionOrderResolver,
+    ConsumptionOrderItemResolver,
 ];
 exports.WmsModuleGraphqlModule = WmsModuleGraphqlModule_1 = class WmsModuleGraphqlModule {
     static forRootAsync(options) {
@@ -7665,25 +8562,31 @@ exports.WmsModuleGraphqlModule = WmsModuleGraphqlModule_1 = class WmsModuleGraph
             disabledOperations,
             disabledFields,
         });
-        // coreOptions still carries `enrichStockEvents`, forwarded to the core module.
-        const coreModule = wmsModuleCore.WmsModuleCoreModule.forRootAsync(coreOptions);
-        const authOptions = { authChecker };
-        // The typed hook maps are a compile-time refinement of the core maps; at
-        // runtime the dispatched payload IS the concrete result type, so handing the
-        // refined maps to the (looser) core option contract is sound.
-        const eventOptions = {
+        /*
+         * The event wiring goes down to the core module rather than being bound
+         * here. `WmsOperationRunner` lives in core so a host calling a service
+         * directly gets the same guarantee, and binding the same tokens in both
+         * modules would leave two live bindings whose winner depends on which
+         * injector the consumer reached first.
+         *
+         * `coreOptions` still carries `enrichStockEvents`, also forwarded.
+         */
+        const coreModule = wmsModuleCore.WmsModuleCoreModule.forRootAsync({
+            ...coreOptions,
+            // The typed hook maps are a compile-time refinement of the core maps; at
+            // runtime the dispatched payload IS the concrete result type, so handing
+            // the refined maps to the (looser) core option contract is sound.
             beforeHooks: beforeHooks,
             afterListeners: afterListeners,
-        };
+            actorExtractor,
+            eventEmitterBridge,
+        });
+        const authOptions = { authChecker };
         const providers = [
             ...exportDependencies,
             exports.WmsAuthGuard,
             { provide: WMS_AUTH_OPTIONS, useValue: authOptions },
-            { provide: wmsModuleCore.WMS_EVENT_OPTIONS, useValue: eventOptions },
-            { provide: wmsModuleCore.WMS_ACTOR_EXTRACTOR, useValue: actorExtractor ?? null },
-            wmsModuleCore.WmsEventDispatcher,
             exports.WmsMutationInterceptor,
-            ...(eventEmitterBridge ? [eventEmitterBridge] : []),
         ];
         return {
             module: WmsModuleGraphqlModule_1,