@rytass/wms-module-graphql 0.10.2 → 0.11.1

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-event.decorator.js → wms-mutation-event.decorator.mjs}

@@ -1,6 +1,6 @@
 import { applyDecorators, SetMetadata, UseInterceptors } from '@nestjs/common';
-import { WMS_MUTATION_EVENT_METADATA } from './wms-mutation-event.constants.js';
-import { WmsMutationInterceptor } from './wms-mutation.interceptor.js';
+import { WMS_MUTATION_EVENT_METADATA } from './wms-mutation-event.constants.mjs';
+import { WmsMutationInterceptor } from './wms-mutation.interceptor.mjs';
 
 /**
  * Declares the operation event for a WMS root mutation and wires the

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.mjs

@@ -0,0 +1,64 @@
+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, WmsOperationRunner } from '@rytass/wms-module-core';
+import { firstValueFrom, of } from 'rxjs';
+import { WMS_MUTATION_EVENT_METADATA } from './wms-mutation-event.constants.mjs';
+
+/**
+ * Hands each `@WmsMutationEvent` mutation to {@link WmsOperationRunner}, which
+ * owns the before-hook / dispatch scope / post-commit flush sequence.
+ *
+ * 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;
+    runner;
+    actorExtractor;
+    constructor(reflector, runner, actorExtractor = null) {
+        this.reflector = reflector;
+        this.runner = runner;
+        this.actorExtractor = actorExtractor;
+    }
+    resolveActor(context) {
+        if (!this.actorExtractor) {
+            return null;
+        }
+        try {
+            return this.actorExtractor(context);
+        }
+        catch {
+            // Fail-open on actor resolution: never break a mutation over audit metadata.
+            return null;
+        }
+    }
+    async intercept(context, next) {
+        const config = this.reflector.get(WMS_MUTATION_EVENT_METADATA, context.getHandler());
+        if (!config) {
+            return next.handle();
+        }
+        const result = await this.runner.run({
+            event: config.event,
+            args: GqlExecutionContext.create(context).getArgs() ?? {},
+            actor: this.resolveActor(context),
+            resolveId: config.resolveId,
+            executionContext: context,
+        }, () => firstValueFrom(next.handle()));
+        return of(result);
+    }
+};
+WmsMutationInterceptor = __decorate([
+    Injectable(),
+    __param(2, Optional()),
+    __param(2, Inject(WMS_ACTOR_EXTRACTOR)),
+    __metadata("design:paramtypes", [Reflector,
+        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 → graphql.module.mjs}

@@ -1,62 +1,67 @@
 import { __decorate } from 'tslib';
 import { Module } from '@nestjs/common';
-import { WmsModuleCoreModule, WMS_EVENT_OPTIONS, WMS_ACTOR_EXTRACTOR, WmsEventDispatcher } from '@rytass/wms-module-core';
-import './helpers/loader.service.js';
-import { HelperModule } from './helpers/helper.module.js';
-import './helpers/query-path.js';
-import { WmsAuthGuard } from './auth/wms-auth.guard.js';
-import { WMS_AUTH_OPTIONS } from './auth/wms-auth.types.js';
-import { WmsMutationInterceptor } from './events/wms-mutation.interceptor.js';
-import { pruneDisabledOperations } from './registry/operation-registry.js';
-import { LoaderMutation } from './mutations/loader.mutation.js';
-import { LoaderQuery } from './queries/loader.query.js';
-import { MaterialMutation } from './mutations/material.mutation.js';
-import { MaterialQuery } from './queries/material.query.js';
-import { StockQuery } from './queries/stock.query.js';
-import { ReceiveInventoryOrderMutation } from './mutations/receive-inventory-order.mutation.js';
-import { ReceiveInventoryOrderQuery } from './queries/recieve-inventory-order.query.js';
-import { ShipInventoryOrderMutation } from './mutations/ship-inventory-order.mutation.js';
-import { ShipInventoryOrderQuery } from './queries/ship-inventory-order.query.js';
-import { LoaderResolver } from './resolvers/loader.resolver.js';
-import { MaterialResolver } from './resolvers/material.resolver.js';
-import { StockResolver } from './resolvers/stock.resolver.js';
-import { WarehouseMapMutation } from './mutations/warehouse-map.mutation.js';
-import { LocationResolver } from './resolvers/location.resolver.js';
-import { LocationQuery } from './queries/location.query.js';
-import { LocationMutation } from './mutations/location.mutation.js';
-import { LoaderTypeResolver } from './resolvers/loader-type.resolver.js';
-import { UnitQuery } from './queries/unit.query.js';
-import { AggregatedStockResolver } from './resolvers/aggregated-stock.resolver.js';
-import { TransferOrderMutation } from './mutations/transfer-order.mutation.js';
-import { TransferOrderQuery } from './queries/transfer-order.query.js';
-import { TransferOrderResolver, TransferOrderItemResolver } from './resolvers/transfer-order.resolver.js';
-import { HoldInventoryOrderMutation } from './mutations/hold-inventory-order.mutation.js';
-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 { 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';
-import { AllocateInventoryOrderResolver } from './resolvers/allocate-inventory-order.resolver.js';
-import { AllocateInventoryOrderMutation } from './mutations/allocate-inventory-order.mutation.js';
-import { ShipInventoryOrderResolver, ShipInventoryOrderItemResolver, ShipInventoryOrderReferenceResolver } from './resolvers/ship-inventory-order.resolver.js';
-import { SaleOrderQuery } from './queries/sale-order.query.js';
-import { SplitBatchMutation } from './mutations/split-batch.mutation.js';
-import { MergeBatchMutation } from './mutations/merge-batch.mutation.js';
-import { ReclassifyInventoryOrderMutation } from './mutations/reclassify-inventory-order.mutation.js';
-import { TransferCustomerOrderMutation } from './mutations/transfer-customer-order.mutation.js';
-import { TransferCustomerOrderResolver } from './resolvers/transfer-customer-order.resolver.js';
-import { TransferVendorOrderMutation } from './mutations/transfer-vendor-order.mutation.js';
-import { TransferVendorOrderResolver } from './resolvers/transfer-vendor-order.resolver.js';
-import { SplitBatchResolver } from './resolvers/split-batch.resolver.js';
-import { MergeBatchOrderResolver } from './resolvers/merge-batch.resolver.js';
-import { ScrapeMutation } from './mutations/scrape-order.mutation.js';
-import { QualityInspectionOrderMutation } from './mutations/quality-inspection-order.mutation.js';
-import { WarehouseMapDataQuery } from './queries/warehouse-map.query.js';
-import { MapRangeUnionResolver } from './resolvers/warehouse-map.resolver.js';
-import { InventoryCountOrderQuery } from './queries/inventory-count-order.query.js';
-import { InventoryCountOrderMutation } from './mutations/inventory-count-order.mutation.js';
-import { InventoryCountOrderResolver, InventoryCountOrderItemResolver } from './resolvers/inventory-count-order.resolver.js';
+import { WmsModuleCoreModule } from '@rytass/wms-module-core';
+import './helpers/loader.service.mjs';
+import { HelperModule } from './helpers/helper.module.mjs';
+import './helpers/query-path.mjs';
+import { WmsAuthGuard } from './auth/wms-auth.guard.mjs';
+import { WMS_AUTH_OPTIONS } from './auth/wms-auth.types.mjs';
+import { WmsMutationInterceptor } from './events/wms-mutation.interceptor.mjs';
+import { pruneDisabledOperations } from './registry/operation-registry.mjs';
+import { LoaderMutation } from './mutations/loader.mutation.mjs';
+import { LoaderQuery } from './queries/loader.query.mjs';
+import { MaterialMutation } from './mutations/material.mutation.mjs';
+import { MaterialQuery } from './queries/material.query.mjs';
+import { StockQuery } from './queries/stock.query.mjs';
+import { ReceiveInventoryOrderMutation } from './mutations/receive-inventory-order.mutation.mjs';
+import { ReceiveInventoryOrderQuery } from './queries/recieve-inventory-order.query.mjs';
+import { ShipInventoryOrderMutation } from './mutations/ship-inventory-order.mutation.mjs';
+import { ShipInventoryOrderQuery } from './queries/ship-inventory-order.query.mjs';
+import { LoaderResolver } from './resolvers/loader.resolver.mjs';
+import { MaterialResolver } from './resolvers/material.resolver.mjs';
+import { StockResolver } from './resolvers/stock.resolver.mjs';
+import { WarehouseMapMutation } from './mutations/warehouse-map.mutation.mjs';
+import { LocationResolver } from './resolvers/location.resolver.mjs';
+import { LocationQuery } from './queries/location.query.mjs';
+import { LocationMutation } from './mutations/location.mutation.mjs';
+import { LoaderTypeResolver } from './resolvers/loader-type.resolver.mjs';
+import { UnitQuery } from './queries/unit.query.mjs';
+import { AggregatedStockResolver } from './resolvers/aggregated-stock.resolver.mjs';
+import { TransferOrderMutation } from './mutations/transfer-order.mutation.mjs';
+import { TransferOrderQuery } from './queries/transfer-order.query.mjs';
+import { TransferOrderResolver, TransferOrderItemResolver } from './resolvers/transfer-order.resolver.mjs';
+import { HoldInventoryOrderMutation } from './mutations/hold-inventory-order.mutation.mjs';
+import { HoldInventoryOrderQuery } from './queries/hold-inventory-order.query.mjs';
+import { HoldInventoryOrderResolver } from './resolvers/hold-inventory-order.resolver.mjs';
+import { BatchQuery } from './queries/batch.query.mjs';
+import { OrderReferenceQuery } from './queries/order-reference.query.mjs';
+import { OrderReferenceMutation } from './mutations/order-reference.mutation.mjs';
+import { ConsumptionOrderQuery } from './queries/consumption-order.query.mjs';
+import { ConsumptionOrderMutation } from './mutations/consumption-order.mutation.mjs';
+import { ConsumptionOrderResolver, ConsumptionOrderItemResolver } from './resolvers/consumption-order.resolver.mjs';
+import { ChangeLogResolver } from './resolvers/change-log.resolver.mjs';
+import { ReceiveInventoryOrderResolver, ReceiveInventoryOrderItemResolver } from './resolvers/receive-inventory-order.resolver.mjs';
+import { AllocateInventoryOrderQuery } from './queries/allocate-inventory-order.query.mjs';
+import { AllocateInventoryOrderResolver } from './resolvers/allocate-inventory-order.resolver.mjs';
+import { AllocateInventoryOrderMutation } from './mutations/allocate-inventory-order.mutation.mjs';
+import { ShipInventoryOrderResolver, ShipInventoryOrderItemResolver, ShipInventoryOrderReferenceResolver } from './resolvers/ship-inventory-order.resolver.mjs';
+import { SaleOrderQuery } from './queries/sale-order.query.mjs';
+import { SplitBatchMutation } from './mutations/split-batch.mutation.mjs';
+import { MergeBatchMutation } from './mutations/merge-batch.mutation.mjs';
+import { ReclassifyInventoryOrderMutation } from './mutations/reclassify-inventory-order.mutation.mjs';
+import { TransferCustomerOrderMutation } from './mutations/transfer-customer-order.mutation.mjs';
+import { TransferCustomerOrderResolver } from './resolvers/transfer-customer-order.resolver.mjs';
+import { TransferVendorOrderMutation } from './mutations/transfer-vendor-order.mutation.mjs';
+import { TransferVendorOrderResolver } from './resolvers/transfer-vendor-order.resolver.mjs';
+import { SplitBatchResolver } from './resolvers/split-batch.resolver.mjs';
+import { MergeBatchOrderResolver } from './resolvers/merge-batch.resolver.mjs';
+import { ScrapeMutation } from './mutations/scrape-order.mutation.mjs';
+import { QualityInspectionOrderMutation } from './mutations/quality-inspection-order.mutation.mjs';
+import { WarehouseMapDataQuery } from './queries/warehouse-map.query.mjs';
+import { MapRangeUnionResolver } from './resolvers/warehouse-map.resolver.mjs';
+import { InventoryCountOrderQuery } from './queries/inventory-count-order.query.mjs';
+import { InventoryCountOrderMutation } from './mutations/inventory-count-order.mutation.mjs';
+import { InventoryCountOrderResolver, InventoryCountOrderItemResolver } from './resolvers/inventory-count-order.resolver.mjs';
 
 var WmsModuleGraphqlModule_1;
 const exportDependencies = [
@@ -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,

package/lib/helpers/{helper.module.js → helper.module.mjs}

@@ -1,6 +1,6 @@
 import { __decorate } from 'tslib';
 import { Global, Module } from '@nestjs/common';
-import { LoaderService } from './loader.service.js';
+import { LoaderService } from './loader.service.mjs';
 
 let HelperModule = class HelperModule {
 };

package/lib/inputs/consumption-order.args.d.ts

@@ -0,0 +1,47 @@
+import { PaginationArgs } from './pagination.args';
+export declare class CreateConsumptionOrderItemInputType {
+    materialId: string;
+    batchId: string;
+    /** Where the material is issued from. Defaults to the module's default location. */
+    locationId?: string;
+    loaderId?: string;
+    unitId?: string;
+    quantity: number;
+    /** Where it sits while the process holds it. Defaults to the source location. */
+    targetLocationId?: string;
+    targetLoaderId?: string;
+}
+export declare class CreateConsumptionOrderArgs {
+    description?: string;
+    createdBy?: string;
+    items: CreateConsumptionOrderItemInputType[];
+}
+export declare class UpdateConsumptionOrderArgs {
+    id: string;
+    description?: string;
+    /** Replaces every line. Refused once the order has moved any stock. */
+    items?: CreateConsumptionOrderItemInputType[];
+}
+export declare class ConsumptionOrderLineInputType {
+    itemId: string;
+    /** Omit for whatever is outstanding on that line. */
+    quantity?: number;
+}
+export declare class ConsumptionOrderActionArgs {
+    orderId: string;
+    /** Omit to act on every line of the order. */
+    items?: ConsumptionOrderLineInputType[];
+}
+export declare class FindConsumptionOrderArgs extends PaginationArgs {
+    ids?: string[];
+    key?: string;
+    description?: string;
+    materialId?: string;
+    batchId?: string;
+    /** Matches either the source or the consuming location. */
+    locationId?: string;
+    createdBy?: string;
+    createdAtFrom?: Date;
+    createdAtTo?: Date;
+    includeRemoved?: boolean;
+}

package/lib/inputs/consumption-order.args.mjs

@@ -0,0 +1,182 @@
+import { __decorate, __metadata } from 'tslib';
+import { Field, ID, Float, InputType, ArgsType } from '@nestjs/graphql';
+import { PaginationArgs } from './pagination.args.mjs';
+
+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;
+};
+__decorate([
+    Field(() => ID),
+    __metadata("design:type", String)
+], CreateConsumptionOrderItemInputType.prototype, "materialId", void 0);
+__decorate([
+    Field(() => ID),
+    __metadata("design:type", String)
+], CreateConsumptionOrderItemInputType.prototype, "batchId", void 0);
+__decorate([
+    Field(() => ID, { nullable: true }),
+    __metadata("design:type", String)
+], CreateConsumptionOrderItemInputType.prototype, "locationId", void 0);
+__decorate([
+    Field(() => ID, { nullable: true }),
+    __metadata("design:type", String)
+], CreateConsumptionOrderItemInputType.prototype, "loaderId", void 0);
+__decorate([
+    Field(() => ID, { nullable: true }),
+    __metadata("design:type", String)
+], CreateConsumptionOrderItemInputType.prototype, "unitId", void 0);
+__decorate([
+    Field(() => Float),
+    __metadata("design:type", Number)
+], CreateConsumptionOrderItemInputType.prototype, "quantity", void 0);
+__decorate([
+    Field(() => ID, { nullable: true }),
+    __metadata("design:type", String)
+], CreateConsumptionOrderItemInputType.prototype, "targetLocationId", void 0);
+__decorate([
+    Field(() => ID, { nullable: true }),
+    __metadata("design:type", String)
+], CreateConsumptionOrderItemInputType.prototype, "targetLoaderId", void 0);
+CreateConsumptionOrderItemInputType = __decorate([
+    InputType()
+], CreateConsumptionOrderItemInputType);
+let CreateConsumptionOrderArgs = class CreateConsumptionOrderArgs {
+    description;
+    createdBy;
+    items;
+};
+__decorate([
+    Field(() => String, { nullable: true }),
+    __metadata("design:type", String)
+], CreateConsumptionOrderArgs.prototype, "description", void 0);
+__decorate([
+    Field(() => String, { nullable: true }),
+    __metadata("design:type", String)
+], CreateConsumptionOrderArgs.prototype, "createdBy", void 0);
+__decorate([
+    Field(() => [CreateConsumptionOrderItemInputType]),
+    __metadata("design:type", Array)
+], CreateConsumptionOrderArgs.prototype, "items", void 0);
+CreateConsumptionOrderArgs = __decorate([
+    ArgsType()
+], CreateConsumptionOrderArgs);
+let UpdateConsumptionOrderArgs = class UpdateConsumptionOrderArgs {
+    id;
+    description;
+    /** Replaces every line. Refused once the order has moved any stock. */
+    items;
+};
+__decorate([
+    Field(() => ID),
+    __metadata("design:type", String)
+], UpdateConsumptionOrderArgs.prototype, "id", void 0);
+__decorate([
+    Field(() => String, { nullable: true }),
+    __metadata("design:type", String)
+], UpdateConsumptionOrderArgs.prototype, "description", void 0);
+__decorate([
+    Field(() => [CreateConsumptionOrderItemInputType], { nullable: true }),
+    __metadata("design:type", Array)
+], UpdateConsumptionOrderArgs.prototype, "items", void 0);
+UpdateConsumptionOrderArgs = __decorate([
+    ArgsType()
+], UpdateConsumptionOrderArgs);
+let ConsumptionOrderLineInputType = class ConsumptionOrderLineInputType {
+    itemId;
+    /** Omit for whatever is outstanding on that line. */
+    quantity;
+};
+__decorate([
+    Field(() => ID),
+    __metadata("design:type", String)
+], ConsumptionOrderLineInputType.prototype, "itemId", void 0);
+__decorate([
+    Field(() => Float, { nullable: true }),
+    __metadata("design:type", Number)
+], ConsumptionOrderLineInputType.prototype, "quantity", void 0);
+ConsumptionOrderLineInputType = __decorate([
+    InputType()
+], ConsumptionOrderLineInputType);
+let ConsumptionOrderActionArgs = class ConsumptionOrderActionArgs {
+    orderId;
+    /** Omit to act on every line of the order. */
+    items;
+};
+__decorate([
+    Field(() => ID),
+    __metadata("design:type", String)
+], ConsumptionOrderActionArgs.prototype, "orderId", void 0);
+__decorate([
+    Field(() => [ConsumptionOrderLineInputType], { nullable: true }),
+    __metadata("design:type", Array)
+], ConsumptionOrderActionArgs.prototype, "items", void 0);
+ConsumptionOrderActionArgs = __decorate([
+    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;
+};
+__decorate([
+    Field(() => [ID], { nullable: true }),
+    __metadata("design:type", Array)
+], FindConsumptionOrderArgs.prototype, "ids", void 0);
+__decorate([
+    Field(() => String, { nullable: true }),
+    __metadata("design:type", String)
+], FindConsumptionOrderArgs.prototype, "key", void 0);
+__decorate([
+    Field(() => String, { nullable: true }),
+    __metadata("design:type", String)
+], FindConsumptionOrderArgs.prototype, "description", void 0);
+__decorate([
+    Field(() => ID, { nullable: true }),
+    __metadata("design:type", String)
+], FindConsumptionOrderArgs.prototype, "materialId", void 0);
+__decorate([
+    Field(() => ID, { nullable: true }),
+    __metadata("design:type", String)
+], FindConsumptionOrderArgs.prototype, "batchId", void 0);
+__decorate([
+    Field(() => ID, { nullable: true }),
+    __metadata("design:type", String)
+], FindConsumptionOrderArgs.prototype, "locationId", void 0);
+__decorate([
+    Field(() => String, { nullable: true }),
+    __metadata("design:type", String)
+], FindConsumptionOrderArgs.prototype, "createdBy", void 0);
+__decorate([
+    Field(() => Date, { nullable: true }),
+    __metadata("design:type", Date)
+], FindConsumptionOrderArgs.prototype, "createdAtFrom", void 0);
+__decorate([
+    Field(() => Date, { nullable: true }),
+    __metadata("design:type", Date)
+], FindConsumptionOrderArgs.prototype, "createdAtTo", void 0);
+__decorate([
+    Field(() => Boolean, { nullable: true }),
+    __metadata("design:type", Boolean)
+], FindConsumptionOrderArgs.prototype, "includeRemoved", void 0);
+FindConsumptionOrderArgs = __decorate([
+    ArgsType()
+], FindConsumptionOrderArgs);
+
+export { ConsumptionOrderActionArgs, ConsumptionOrderLineInputType, CreateConsumptionOrderArgs, CreateConsumptionOrderItemInputType, FindConsumptionOrderArgs, UpdateConsumptionOrderArgs };

package/lib/inputs/{create-allocate-inventory-order.args.js → create-allocate-inventory-order.args.mjs}

@@ -1,6 +1,6 @@
 import { __decorate, __metadata } from 'tslib';
 import { Field, ArgsType, PartialType, OmitType } from '@nestjs/graphql';
-import { CreateAllocateInventoryOrderItemArgs, UpdateAllocateInventoryOrderItemArgs } from './create-allocate-inventory-order-item.args.js';
+import { CreateAllocateInventoryOrderItemArgs, UpdateAllocateInventoryOrderItemArgs } from './create-allocate-inventory-order-item.args.mjs';
 
 let CreateAllocateInventoryOrderArgs = class CreateAllocateInventoryOrderArgs {
     items;

package/lib/inputs/{create-hold-inventory-order.args.js → create-hold-inventory-order.args.mjs}

@@ -1,6 +1,6 @@
 import { __decorate, __metadata } from 'tslib';
 import { Field, ArgsType, PartialType, OmitType } from '@nestjs/graphql';
-import { CreateHoldInventoryOrderItemArgs, UpdateHoldInventoryOrderItemArgs } from './create-hold-inventory-order-item.args.js';
+import { CreateHoldInventoryOrderItemArgs, UpdateHoldInventoryOrderItemArgs } from './create-hold-inventory-order-item.args.mjs';
 
 let CreateHoldInventoryOrderArgs = class CreateHoldInventoryOrderArgs {
     createdBy;

package/lib/inputs/{create-material.args.js → create-material.args.mjs}

@@ -1,6 +1,6 @@
 import { __decorate, __metadata } from 'tslib';
 import { Field, ArgsType, PartialType, OmitType, ID } from '@nestjs/graphql';
-import { CreateMaterialUnitArgs } from './create-material-unit.args.js';
+import { CreateMaterialUnitArgs } from './create-material-unit.args.mjs';
 
 let CreateMaterialArgs = class CreateMaterialArgs {
     key;