@rytass/wms-module-graphql 0.10.1 → 0.11.0

package/lib/dto/consumption-order-item.dto.d.ts

@@ -0,0 +1,17 @@
+export declare class ConsumptionOrderItemDto {
+    id: string;
+    materialId: string;
+    batchId: string;
+    locationId: string;
+    loaderId: string | null;
+    targetLocationId: string | null;
+    targetLoaderId: string | null;
+    orderId: string;
+    unitId: string | null;
+    targetConsumedQuantity: number;
+    removedAt: Date | null;
+}
+declare const ConsumptionOrderItems_base: new () => import("./pagination.dto").PaginatedType<ConsumptionOrderItemDto>;
+export declare class ConsumptionOrderItems extends ConsumptionOrderItems_base {
+}
+export {};

package/lib/dto/consumption-order-item.dto.js

@@ -0,0 +1,43 @@
+import { __decorate, __metadata } from 'tslib';
+import { Field, ID, Float, ObjectType } from '@nestjs/graphql';
+import { PaginatedResponse } from './pagination.dto.js';
+
+let ConsumptionOrderItemDto = class ConsumptionOrderItemDto {
+    id;
+    materialId;
+    batchId;
+    locationId;
+    loaderId;
+    targetLocationId;
+    targetLoaderId;
+    orderId;
+    unitId;
+    targetConsumedQuantity;
+    removedAt;
+};
+__decorate([
+    Field(() => ID),
+    __metadata("design:type", String)
+], ConsumptionOrderItemDto.prototype, "id", void 0);
+__decorate([
+    Field(() => String, { nullable: true }),
+    __metadata("design:type", Object)
+], ConsumptionOrderItemDto.prototype, "unitId", void 0);
+__decorate([
+    Field(() => Float),
+    __metadata("design:type", Number)
+], ConsumptionOrderItemDto.prototype, "targetConsumedQuantity", void 0);
+__decorate([
+    Field(() => Date, { nullable: true }),
+    __metadata("design:type", Object)
+], ConsumptionOrderItemDto.prototype, "removedAt", void 0);
+ConsumptionOrderItemDto = __decorate([
+    ObjectType()
+], ConsumptionOrderItemDto);
+let ConsumptionOrderItems = class ConsumptionOrderItems extends PaginatedResponse(ConsumptionOrderItemDto) {
+};
+ConsumptionOrderItems = __decorate([
+    ObjectType()
+], ConsumptionOrderItems);
+
+export { ConsumptionOrderItemDto, ConsumptionOrderItems };

package/lib/dto/consumption-order.dto.d.ts

@@ -0,0 +1,14 @@
+import { ConsumptionOrderItemDto } from './consumption-order-item.dto';
+export declare class ConsumptionOrderDto {
+    id: string;
+    key: string;
+    description: string | null;
+    createdBy: string | null;
+    removedAt: Date | null;
+    createdAt: Date;
+    items: ConsumptionOrderItemDto[];
+}
+declare const ConsumptionOrders_base: new () => import("./pagination.dto").PaginatedType<ConsumptionOrderDto>;
+export declare class ConsumptionOrders extends ConsumptionOrders_base {
+}
+export {};

package/lib/dto/consumption-order.dto.js

@@ -0,0 +1,52 @@
+import { __decorate, __metadata } from 'tslib';
+import { Field, ID, ObjectType } from '@nestjs/graphql';
+import { ConsumptionOrderItemDto } from './consumption-order-item.dto.js';
+import { PaginatedResponse } from './pagination.dto.js';
+
+let ConsumptionOrderDto = class ConsumptionOrderDto {
+    id;
+    key;
+    description;
+    createdBy;
+    removedAt;
+    createdAt;
+    items;
+};
+__decorate([
+    Field(() => ID),
+    __metadata("design:type", String)
+], ConsumptionOrderDto.prototype, "id", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], ConsumptionOrderDto.prototype, "key", void 0);
+__decorate([
+    Field(() => String, { nullable: true }),
+    __metadata("design:type", Object)
+], ConsumptionOrderDto.prototype, "description", void 0);
+__decorate([
+    Field(() => String, { nullable: true }),
+    __metadata("design:type", Object)
+], ConsumptionOrderDto.prototype, "createdBy", void 0);
+__decorate([
+    Field(() => Date, { nullable: true }),
+    __metadata("design:type", Object)
+], ConsumptionOrderDto.prototype, "removedAt", void 0);
+__decorate([
+    Field(() => Date),
+    __metadata("design:type", Date)
+], ConsumptionOrderDto.prototype, "createdAt", void 0);
+__decorate([
+    Field(() => [ConsumptionOrderItemDto]),
+    __metadata("design:type", Array)
+], ConsumptionOrderDto.prototype, "items", void 0);
+ConsumptionOrderDto = __decorate([
+    ObjectType()
+], ConsumptionOrderDto);
+let ConsumptionOrders = class ConsumptionOrders extends PaginatedResponse(ConsumptionOrderDto) {
+};
+ConsumptionOrders = __decorate([
+    ObjectType()
+], ConsumptionOrders);
+
+export { ConsumptionOrderDto, ConsumptionOrders };

package/lib/dto/index.d.ts

@@ -23,3 +23,6 @@ export * from './scrape-order-item.dto';
 export * from './quality-inspection-order.dto';
 export * from './quality-inspection-order-item.dto';
 export * from './inventory-count-order.dto';
+export * from './consumption-order.dto';
+export * from './consumption-order-item.dto';
+export * from './order-reference.dto';

package/lib/dto/inventory-count-order.dto.d.ts

@@ -23,8 +23,14 @@ export declare class InventoryCountOrderItemDto {
     isAddition: boolean;
     held: boolean | null;
     inShipment: boolean | null;
-    /** `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: boolean | null;
+    /** Whether anybody had asked for this position to be inspected. */
+    requiresInspection: boolean | null;
     transferId: string | null;
     vendorId: string | null;
     customerId: string | null;

package/lib/dto/inventory-count-order.dto.js

@@ -36,8 +36,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;
@@ -96,6 +102,10 @@ __decorate([
     Field(() => Boolean, { nullable: true }),
     __metadata("design:type", Object)
 ], InventoryCountOrderItemDto.prototype, "inspectionResult", void 0);
+__decorate([
+    Field(() => Boolean, { nullable: true }),
+    __metadata("design:type", Object)
+], InventoryCountOrderItemDto.prototype, "requiresInspection", void 0);
 __decorate([
     Field(() => ID, { nullable: true }),
     __metadata("design:type", Object)

package/lib/dto/order-reference.dto.d.ts

@@ -0,0 +1,22 @@
+import { WmsOrderType } from '@rytass/wms-module-core';
+/**
+ * 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`).
+ */
+export declare class OrderReferenceDto {
+    id: string;
+    orderType: WmsOrderType;
+    orderId: string;
+    itemId: string | null;
+    referenceType: string;
+    referenceId: string;
+    referenceLine: string | null;
+    metadata: Record<string, unknown> | null;
+    createdAt: Date;
+}
+declare const OrderReferences_base: new () => import("./pagination.dto").PaginatedType<OrderReferenceDto>;
+export declare class OrderReferences extends OrderReferences_base {
+}
+export {};

package/lib/dto/order-reference.dto.js

@@ -0,0 +1,73 @@
+import { __decorate, __metadata } from 'tslib';
+import { registerEnumType, Field, ID, ObjectType } from '@nestjs/graphql';
+import { WmsOrderType } from '@rytass/wms-module-core';
+import { GraphQLJSONObject } from '../scalars/json-object.scalar.js';
+import { PaginatedResponse } from './pagination.dto.js';
+
+registerEnumType(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;
+};
+__decorate([
+    Field(() => ID),
+    __metadata("design:type", String)
+], OrderReferenceDto.prototype, "id", void 0);
+__decorate([
+    Field(() => WmsOrderType),
+    __metadata("design:type", String)
+], OrderReferenceDto.prototype, "orderType", void 0);
+__decorate([
+    Field(() => ID),
+    __metadata("design:type", String)
+], OrderReferenceDto.prototype, "orderId", void 0);
+__decorate([
+    Field(() => ID, { nullable: true }),
+    __metadata("design:type", Object)
+], OrderReferenceDto.prototype, "itemId", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], OrderReferenceDto.prototype, "referenceType", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], OrderReferenceDto.prototype, "referenceId", void 0);
+__decorate([
+    Field(() => String, { nullable: true }),
+    __metadata("design:type", Object)
+], OrderReferenceDto.prototype, "referenceLine", void 0);
+__decorate([
+    Field(() => GraphQLJSONObject, { nullable: true }),
+    __metadata("design:type", Object)
+], OrderReferenceDto.prototype, "metadata", void 0);
+__decorate([
+    Field(() => Date),
+    __metadata("design:type", Date)
+], OrderReferenceDto.prototype, "createdAt", void 0);
+OrderReferenceDto = __decorate([
+    ObjectType()
+], OrderReferenceDto);
+let OrderReferences = class OrderReferences extends PaginatedResponse(OrderReferenceDto) {
+};
+OrderReferences = __decorate([
+    ObjectType()
+], OrderReferences);
+
+export { OrderReferenceDto, OrderReferences };

package/lib/dto/stock.dto.d.ts

@@ -23,6 +23,21 @@ export declare class AggregatedStockDto {
     customerId?: string | null;
     vendorId?: string | null;
     inspectionResult?: boolean;
+    /**
+     * 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?: boolean;
+    /**
+     * 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?: string | null;
+    attributes?: Record<string, unknown> | null;
 }
 declare const AggregatedStocks_base: new () => import("./pagination.dto").PaginatedType<AggregatedStockDto>;
 export declare class AggregatedStocks extends AggregatedStocks_base {

package/lib/dto/stock.dto.js

@@ -2,6 +2,7 @@ import { __decorate, __metadata } from 'tslib';
 import { Field, ID, Int, ObjectType, registerEnumType } from '@nestjs/graphql';
 import { PaginatedResponse } from './pagination.dto.js';
 import { StockStatus, ChangeType } from '@rytass/wms-module-core';
+import { GraphQLJSONObject } from '../scalars/json-object.scalar.js';
 
 let StockDto = class StockDto {
     id;
@@ -48,6 +49,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;
 };
 __decorate([
     Field(() => Int),
@@ -89,6 +105,18 @@ __decorate([
     Field(() => Boolean, { nullable: true }),
     __metadata("design:type", Boolean)
 ], AggregatedStockDto.prototype, "inspectionResult", void 0);
+__decorate([
+    Field(() => Boolean, { nullable: true }),
+    __metadata("design:type", Boolean)
+], AggregatedStockDto.prototype, "requiresInspection", void 0);
+__decorate([
+    Field(() => ID, { nullable: true }),
+    __metadata("design:type", Object)
+], AggregatedStockDto.prototype, "parentBatchId", void 0);
+__decorate([
+    Field(() => GraphQLJSONObject, { nullable: true }),
+    __metadata("design:type", Object)
+], AggregatedStockDto.prototype, "attributes", void 0);
 AggregatedStockDto = __decorate([
     ObjectType()
 ], AggregatedStockDto);

package/lib/events/operation-result-map.d.ts

@@ -17,6 +17,8 @@ import type { MapDataDto } from '../dto/warehouse-map.dto';
 import type { MergeBatchOrderDto } from '../dto/merge-batch-order.dto';
 import type { ReclassifyInventoryOrderDto } from '../dto/reclassify-inventory-order.dto';
 import type { SplitBatchOrderDto } from '../dto/split-batch-order.dto';
+import type { OrderReferenceDto } from '../dto/order-reference.dto';
+import type { ConsumptionOrderDto } from '../dto/consumption-order.dto';
 /**
  * Maps every {@link WmsOperationEventName} to the concrete type returned by
  * the corresponding mutation resolver.
@@ -68,6 +70,17 @@ export interface WmsOperationResultMap extends Record<WmsOperationEventName, unk
     'batch.splitted': SplitBatchOrderDto;
     'scrape-order.scraped': ScrapeOrderDto;
     'quality-inspection-order.inspected': QualityInspectionOrderDto;
+    'consumption-order.created': ConsumptionOrderDto;
+    'consumption-order.updated': ConsumptionOrderDto;
+    /** Action mutation — result is a success flag; use args + stock.issued. */
+    'consumption-order.issued': boolean;
+    /** Action mutation — result is a success flag; use args + stock.returned. */
+    'consumption-order.returned': boolean;
+    /** Action mutation — result is a success flag; use args + stock.consumed. */
+    'consumption-order.settled': boolean;
+    'order-reference.attached': OrderReferenceDto[];
+    /** Action mutation — result is a success flag; the id is in `args`. */
+    'order-reference.detached': boolean;
     'transfer-order.created': TransferOrderDto;
     'transfer-order.updated': TransferOrderDto;
     /** Action mutation — result is a success flag; use args + stock.transferred. */

package/lib/events/typed-maps.d.ts

@@ -37,17 +37,27 @@ export interface WmsTypedAfterEventContext<N extends WmsEventName> {
 }
 /**
  * Context passed to a before-hook.  Runs *before* any DB work, so
- * `payload` / `result` are not yet available — only the raw GraphQL
- * arguments (`args`) and the resolved actor.  Throwing from a before-hook
- * vetoes the mutation with zero side effects.
+ * `payload` / `result` are not yet available — only the raw arguments
+ * (`args`) and the resolved actor.  Throwing from a before-hook vetoes the
+ * operation with zero side effects.
+ *
+ * Structurally identical to the core `WmsBeforeHookContext`; the two must stay
+ * in step, because a hook written against either is handed the same object.
  */
 export interface WmsTypedBeforeHookContext<N extends WmsEventName> {
     readonly event: N;
-    /** Raw GraphQL arguments — the mutation intent (per §3.4 of the design doc). */
+    /** Raw arguments — the operation's intent (per §3.4 of the design doc). */
     readonly args: Readonly<Record<string, unknown>>;
-    /** The NestJS execution context at the time of the mutation call. */
-    readonly executionContext: ExecutionContext;
-    /** Who performed the mutation; `null` when no `actorExtractor` is configured. */
+    /**
+     * The NestJS execution context, or `null` when the operation did not arrive
+     * through one — a host driving a domain service through
+     * `WmsOperationRunner`. Branch on {@link WmsTypedBeforeHookContext.source}
+     * rather than on this being present.
+     */
+    readonly executionContext: ExecutionContext | null;
+    /** Where the operation came in from. `'host'` means a direct service call. */
+    readonly source: 'graphql' | 'host';
+    /** Who performed the operation; `null` when no `actorExtractor` is configured. */
     readonly actor: WmsActor | null;
 }
 /**

package/lib/events/wms-mutation.interceptor.d.ts

@@ -1,21 +1,23 @@
 import { type CallHandler, type ExecutionContext, type NestInterceptor } from '@nestjs/common';
 import { Reflector } from '@nestjs/core';
-import { WmsEventDispatcher, type WmsActorExtractor } from '@rytass/wms-module-core';
+import { WmsOperationRunner, type WmsActorExtractor } from '@rytass/wms-module-core';
 import { type Observable } from 'rxjs';
 /**
- * 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.
  */
 export declare class WmsMutationInterceptor implements NestInterceptor {
     private readonly reflector;
-    private readonly dispatcher;
+    private readonly runner;
     private readonly actorExtractor;
-    constructor(reflector: Reflector, dispatcher: WmsEventDispatcher, actorExtractor?: WmsActorExtractor | null);
+    constructor(reflector: Reflector, runner: WmsOperationRunner, actorExtractor?: WmsActorExtractor | null);
     private resolveActor;
     intercept(context: ExecutionContext, next: CallHandler): Promise<Observable<unknown>>;
 }

package/lib/events/wms-mutation.interceptor.js

@@ -2,36 +2,28 @@ import { __decorate, __param, __metadata } from 'tslib';
 import { Injectable, Optional, Inject } from '@nestjs/common';
 import { Reflector } from '@nestjs/core';
 import { GqlExecutionContext } from '@nestjs/graphql';
-import { WMS_ACTOR_EXTRACTOR, WmsEventDispatcher, runInDispatchScope, collectToScope } from '@rytass/wms-module-core';
+import { WMS_ACTOR_EXTRACTOR, WmsOperationRunner } from '@rytass/wms-module-core';
 import { firstValueFrom, of } from 'rxjs';
 import { WMS_MUTATION_EVENT_METADATA } from './wms-mutation-event.constants.js';
 
-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.
  */
 let 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) {
@@ -48,34 +40,16 @@ let 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 = 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: GqlExecutionContext.create(context).getArgs() ?? {},
+            actor: this.resolveActor(context),
+            resolveId: config.resolveId,
             executionContext: context,
-            actor,
-        });
-        const { result, events } = await runInDispatchScope(async () => {
-            const handlerResult = await 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 },
-            };
-            collectToScope(operationEvent);
-            return handlerResult;
-        });
-        if (events) {
-            await this.dispatcher.flush(events);
-        }
+        }, () => firstValueFrom(next.handle()));
         return of(result);
     }
 };
@@ -84,7 +58,7 @@ WmsMutationInterceptor = __decorate([
     __param(2, Optional()),
     __param(2, Inject(WMS_ACTOR_EXTRACTOR)),
     __metadata("design:paramtypes", [Reflector,
-        WmsEventDispatcher, Object])
+        WmsOperationRunner, Object])
 ], WmsMutationInterceptor);
 
 export { WmsMutationInterceptor };

package/lib/graphql.module.d.ts

@@ -24,7 +24,7 @@ import { type WmsOperationRegistrationOptions } from './registry';
  * Everything is optional; with nothing configured the module behaves exactly as
  * before (no events emitted, fully permissive, every operation registered).
  */
-export type WmsModuleGraphqlModuleAsyncOptions = WmsModuleCoreModuleAsyncOptions & WmsAuthModuleOptions & WmsOperationRegistrationOptions & {
+export type WmsModuleGraphqlModuleAsyncOptions = Omit<WmsModuleCoreModuleAsyncOptions, 'beforeHooks' | 'afterListeners'> & WmsAuthModuleOptions & WmsOperationRegistrationOptions & {
     readonly beforeHooks?: WmsTypedBeforeHookMap;
     readonly afterListeners?: WmsTypedAfterListenerMap;
     readonly actorExtractor?: WmsActorExtractor;

package/lib/graphql.module.js

@@ -1,6 +1,6 @@
 import { __decorate } from 'tslib';
 import { Module } from '@nestjs/common';
-import { WmsModuleCoreModule, WMS_EVENT_OPTIONS, WMS_ACTOR_EXTRACTOR, WmsEventDispatcher } from '@rytass/wms-module-core';
+import { WmsModuleCoreModule } from '@rytass/wms-module-core';
 import './helpers/loader.service.js';
 import { HelperModule } from './helpers/helper.module.js';
 import './helpers/query-path.js';
@@ -34,6 +34,11 @@ import { HoldInventoryOrderMutation } from './mutations/hold-inventory-order.mut
 import { HoldInventoryOrderQuery } from './queries/hold-inventory-order.query.js';
 import { HoldInventoryOrderResolver } from './resolvers/hold-inventory-order.resolver.js';
 import { BatchQuery } from './queries/batch.query.js';
+import { OrderReferenceQuery } from './queries/order-reference.query.js';
+import { OrderReferenceMutation } from './mutations/order-reference.mutation.js';
+import { ConsumptionOrderQuery } from './queries/consumption-order.query.js';
+import { ConsumptionOrderMutation } from './mutations/consumption-order.mutation.js';
+import { ConsumptionOrderResolver, ConsumptionOrderItemResolver } from './resolvers/consumption-order.resolver.js';
 import { ChangeLogResolver } from './resolvers/change-log.resolver.js';
 import { ReceiveInventoryOrderResolver, ReceiveInventoryOrderItemResolver } from './resolvers/receive-inventory-order.resolver.js';
 import { AllocateInventoryOrderQuery } from './queries/allocate-inventory-order.query.js';
@@ -116,6 +121,12 @@ const exportDependencies = [
     InventoryCountOrderMutation,
     InventoryCountOrderResolver,
     InventoryCountOrderItemResolver,
+    OrderReferenceQuery,
+    OrderReferenceMutation,
+    ConsumptionOrderQuery,
+    ConsumptionOrderMutation,
+    ConsumptionOrderResolver,
+    ConsumptionOrderItemResolver,
 ];
 let WmsModuleGraphqlModule = WmsModuleGraphqlModule_1 = class WmsModuleGraphqlModule {
     static forRootAsync(options) {
@@ -129,25 +140,31 @@ let WmsModuleGraphqlModule = WmsModuleGraphqlModule_1 = class WmsModuleGraphqlMo
             disabledOperations,
             disabledFields,
         });
-        // coreOptions still carries `enrichStockEvents`, forwarded to the core module.
-        const coreModule = 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 = 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,
             WmsAuthGuard,
             { provide: WMS_AUTH_OPTIONS, useValue: authOptions },
-            { provide: WMS_EVENT_OPTIONS, useValue: eventOptions },
-            { provide: WMS_ACTOR_EXTRACTOR, useValue: actorExtractor ?? null },
-            WmsEventDispatcher,
             WmsMutationInterceptor,
-            ...(eventEmitterBridge ? [eventEmitterBridge] : []),
         ];
         return {
             module: WmsModuleGraphqlModule_1,