@rytass/wms-module-graphql 0.8.0 → 0.9.0

package/index.cjs.js

@@ -465,6 +465,138 @@ exports.WmsMutationInterceptor = tslib.__decorate([
  */
 const WmsMutationEvent = (config) => common.applyDecorators(common.SetMetadata(WMS_MUTATION_EVENT_METADATA, config), common.UseInterceptors(exports.WmsMutationInterceptor));
 
+function resolveDisabled(options) {
+    const { enabledOperations, disabledOperations, disabledFields } = options;
+    if (enabledOperations && disabledOperations) {
+        throw new Error('[wms-module-graphql] `enabledOperations` and `disabledOperations` are mutually exclusive — pass one or the other, not both.');
+    }
+    const enabled = enabledOperations ? new Set(enabledOperations) : null;
+    const disabled = disabledOperations
+        ? new Set(disabledOperations)
+        : null;
+    const fields = new Set(disabledFields ?? []);
+    return {
+        hasSwitches: enabled !== null || disabled !== null || fields.size > 0,
+        isOperationDisabled: (name) => {
+            if (enabled) {
+                return !enabled.has(name);
+            }
+            if (disabled) {
+                return disabled.has(name);
+            }
+            return false;
+        },
+        disabledFields: fields,
+    };
+}
+/** Methods already pruned, so the metadata filter can drop their entries. */
+const prunedMethods = new WeakMap();
+let metadataFilterInstalled = false;
+/**
+ * Stop the pruned operations from ever entering `TypeMetadataStorage`.
+ *
+ * The resolver metadata is **lazy**: `@Query()` / `@Mutation()` only register a
+ * thunk with `LazyMetadataStorage`, and the thunk calls `add*Metadata` when
+ * `GraphQLSchemaBuilder.build()` loads it. At `forRootAsync` time the storage
+ * arrays are therefore still empty, and filtering them then would remove
+ * nothing — so the filter has to sit on the writes instead.
+ */
+function installMetadataFilter() {
+    if (metadataFilterInstalled) {
+        return;
+    }
+    const storage = graphql.TypeMetadataStorage;
+    const addQuery = storage.addQueryMetadata.bind(storage);
+    const addMutation = storage.addMutationMetadata.bind(storage);
+    const isPruned = (metadata) => prunedMethods.get(metadata.target)?.has(metadata.methodName) === true;
+    storage.addQueryMetadata = (metadata) => {
+        if (isPruned(metadata)) {
+            return;
+        }
+        addQuery(metadata);
+    };
+    storage.addMutationMetadata = (metadata) => {
+        if (isPruned(metadata)) {
+            return;
+        }
+        addMutation(metadata);
+    };
+    metadataFilterInstalled = true;
+}
+/** The GraphQL field name a root handler ends up under. */
+function schemaNameOf(handler, methodName) {
+    const explicit = Reflect.getMetadata(graphql.RESOLVER_NAME_METADATA, handler);
+    return explicit || methodName;
+}
+/**
+ * Remove the switched-off root operations before the schema is built.
+ *
+ * Two edits are needed, at two different moments, and they must happen together:
+ *
+ * 1. **now** — `delete Resolver.prototype[method]`, because
+ *    `ResolversExplorerService.explore()` walks the prototype with
+ *    `MetadataScanner` and runs *before* the schema builder loads the lazy
+ *    metadata. Leaving the method in place would put `Query.foo` in the resolver
+ *    map with no matching field in the typeDefs, and `makeExecutableSchema`
+ *    rejects the whole schema (`requireResolversToMatchSchema`).
+ * 2. **at load time** — drop the metadata entry ({@link installMetadataFilter}),
+ *    or the SDL would still declare a field that resolves to `null`: present,
+ *    but dead.
+ *
+ * Deleting the prototype method does not disturb step 2's type reflection:
+ * `design:returntype` is stored against the prototype and property key, not
+ * against the function object, so it survives the delete.
+ *
+ * This runs synchronously from `forRootAsync`, i.e. while `AppModule` is still
+ * being defined. Both the classes and the storage are process-global, so a
+ * process may register `WmsModuleGraphqlModule` only once.
+ */
+function pruneDisabledOperations(resolverClasses, options) {
+    const { hasSwitches, isOperationDisabled, disabledFields } = resolveDisabled(options);
+    if (!hasSwitches) {
+        return { queries: [], mutations: [] };
+    }
+    installMetadataFilter();
+    const queries = [];
+    const mutations = [];
+    for (const resolverClass of resolverClasses) {
+        const prototype = resolverClass.prototype;
+        if (!prototype) {
+            continue;
+        }
+        for (const methodName of Object.getOwnPropertyNames(prototype)) {
+            if (methodName === 'constructor') {
+                continue;
+            }
+            const handler = prototype[methodName];
+            if (typeof handler !== 'function') {
+                continue;
+            }
+            const resolverType = Reflect.getMetadata(graphql.RESOLVER_TYPE_METADATA, handler);
+            // Only root operations are switchable. `@ResolveField` handlers are
+            // reached exclusively through an already-registered root field, so
+            // removing one would break the type rather than the deployment surface.
+            if (resolverType !== 'Query' && resolverType !== 'Mutation') {
+                continue;
+            }
+            const schemaName = schemaNameOf(handler, methodName);
+            const requirement = Reflect.getMetadata(WMS_OPERATION_METADATA, handler);
+            const disabled = disabledFields.has(schemaName) ||
+                (requirement !== undefined &&
+                    isOperationDisabled(`${requirement.resource}:${requirement.action}`));
+            if (!disabled) {
+                continue;
+            }
+            const alreadyPruned = prunedMethods.get(resolverClass) ?? new Set();
+            alreadyPruned.add(methodName);
+            prunedMethods.set(resolverClass, alreadyPruned);
+            delete prototype[methodName];
+            (resolverType === 'Query' ? queries : mutations).push(schemaName);
+        }
+    }
+    return { queries, mutations };
+}
+
 const IdGenFunction = (input) => {
     const hash = crypto.createHash('sha256');
     hash.update(input);
@@ -1602,6 +1734,146 @@ QualityInspectionOrders = tslib.__decorate([
     graphql.ObjectType()
 ], QualityInspectionOrders);
 
+graphql.registerEnumType(wmsModuleCore.InventoryCountStatus, {
+    name: 'InventoryCountStatus',
+    description: 'Lifecycle of an inventory count: PENDING (尚未執行) → COUNTING (盤點中) → COMPLETED (已完成), or CANCELLED (已取消).',
+});
+/**
+ * A count-sheet line.
+ *
+ * `material` / `batch` / `location` / `loader` are deliberately absent from this
+ * class: they are added to the schema by `InventoryCountOrderItemResolver` as
+ * `@ResolveField`s so they load through DataLoaders, and declaring them here
+ * would make the class stop matching the entity the service returns.
+ */
+let InventoryCountOrderItemDto = class InventoryCountOrderItemDto {
+    id;
+    orderId;
+    materialId;
+    batchId;
+    locationId;
+    loaderId;
+    unitId;
+    /** Ledger quantity in base units, frozen when counting started. */
+    bookQuantity;
+    /** What was found, expressed in `unitId`. `null` until someone counts it. */
+    countedQuantity;
+    /** `true` for a line added during counting for stock the books never had. */
+    isAddition;
+};
+tslib.__decorate([
+    graphql.Field(() => graphql.ID),
+    tslib.__metadata("design:type", String)
+], InventoryCountOrderItemDto.prototype, "id", void 0);
+tslib.__decorate([
+    graphql.Field(() => graphql.ID),
+    tslib.__metadata("design:type", String)
+], InventoryCountOrderItemDto.prototype, "orderId", void 0);
+tslib.__decorate([
+    graphql.Field(() => graphql.ID),
+    tslib.__metadata("design:type", String)
+], InventoryCountOrderItemDto.prototype, "materialId", void 0);
+tslib.__decorate([
+    graphql.Field(() => graphql.ID),
+    tslib.__metadata("design:type", String)
+], InventoryCountOrderItemDto.prototype, "batchId", void 0);
+tslib.__decorate([
+    graphql.Field(() => graphql.ID, { nullable: true }),
+    tslib.__metadata("design:type", Object)
+], InventoryCountOrderItemDto.prototype, "locationId", void 0);
+tslib.__decorate([
+    graphql.Field(() => graphql.ID, { nullable: true }),
+    tslib.__metadata("design:type", Object)
+], InventoryCountOrderItemDto.prototype, "loaderId", void 0);
+tslib.__decorate([
+    graphql.Field(() => graphql.ID, { nullable: true }),
+    tslib.__metadata("design:type", Object)
+], InventoryCountOrderItemDto.prototype, "unitId", void 0);
+tslib.__decorate([
+    graphql.Field(() => graphql.Float),
+    tslib.__metadata("design:type", Number)
+], InventoryCountOrderItemDto.prototype, "bookQuantity", void 0);
+tslib.__decorate([
+    graphql.Field(() => graphql.Float, { nullable: true }),
+    tslib.__metadata("design:type", Object)
+], InventoryCountOrderItemDto.prototype, "countedQuantity", void 0);
+tslib.__decorate([
+    graphql.Field(() => Boolean),
+    tslib.__metadata("design:type", Boolean)
+], InventoryCountOrderItemDto.prototype, "isAddition", void 0);
+InventoryCountOrderItemDto = tslib.__decorate([
+    graphql.ObjectType()
+], InventoryCountOrderItemDto);
+/**
+ * A count order. `items` and `locations` come from
+ * `InventoryCountOrderResolver`, for the same reason as above; `locations`
+ * exposes the roots the user picked, not the expanded subtree.
+ */
+let InventoryCountOrderDto = class InventoryCountOrderDto {
+    id;
+    key;
+    name;
+    /**
+     * The count's base date. Stock adjustments from settlement are reported under
+     * this date rather than the day settlement happened to run.
+     */
+    countDate;
+    status;
+    createdBy;
+    startedAt;
+    settledAt;
+    cancelledAt;
+    createdAt;
+};
+tslib.__decorate([
+    graphql.Field(() => graphql.ID),
+    tslib.__metadata("design:type", String)
+], InventoryCountOrderDto.prototype, "id", void 0);
+tslib.__decorate([
+    graphql.Field(() => String),
+    tslib.__metadata("design:type", String)
+], InventoryCountOrderDto.prototype, "key", void 0);
+tslib.__decorate([
+    graphql.Field(() => String),
+    tslib.__metadata("design:type", String)
+], InventoryCountOrderDto.prototype, "name", void 0);
+tslib.__decorate([
+    graphql.Field(() => String),
+    tslib.__metadata("design:type", String)
+], InventoryCountOrderDto.prototype, "countDate", void 0);
+tslib.__decorate([
+    graphql.Field(() => wmsModuleCore.InventoryCountStatus),
+    tslib.__metadata("design:type", String)
+], InventoryCountOrderDto.prototype, "status", void 0);
+tslib.__decorate([
+    graphql.Field(() => String, { nullable: true }),
+    tslib.__metadata("design:type", Object)
+], InventoryCountOrderDto.prototype, "createdBy", void 0);
+tslib.__decorate([
+    graphql.Field(() => Date, { nullable: true }),
+    tslib.__metadata("design:type", Object)
+], InventoryCountOrderDto.prototype, "startedAt", void 0);
+tslib.__decorate([
+    graphql.Field(() => Date, { nullable: true }),
+    tslib.__metadata("design:type", Object)
+], InventoryCountOrderDto.prototype, "settledAt", void 0);
+tslib.__decorate([
+    graphql.Field(() => Date, { nullable: true }),
+    tslib.__metadata("design:type", Object)
+], InventoryCountOrderDto.prototype, "cancelledAt", void 0);
+tslib.__decorate([
+    graphql.Field(() => Date),
+    tslib.__metadata("design:type", Date)
+], InventoryCountOrderDto.prototype, "createdAt", void 0);
+InventoryCountOrderDto = tslib.__decorate([
+    graphql.ObjectType()
+], InventoryCountOrderDto);
+let InventoryCountOrders = class InventoryCountOrders extends PaginatedResponse(InventoryCountOrderDto) {
+};
+InventoryCountOrders = tslib.__decorate([
+    graphql.ObjectType()
+], InventoryCountOrders);
+
 let CreateLoaderTypeArgs = class CreateLoaderTypeArgs {
     description;
     key;
@@ -6678,6 +6950,494 @@ MapRangeUnionResolver = tslib.__decorate([
     tslib.__metadata("design:paramtypes", [wmsModuleCore.WmsEntities])
 ], MapRangeUnionResolver);
 
+let FindInventoryCountOrderArgs = class FindInventoryCountOrderArgs extends PaginationArgs {
+    name;
+    statuses;
+    createdBy;
+    /** Inclusive lower bound on `countDate`, `YYYY-MM-DD`. */
+    countDateFrom;
+    /** Inclusive upper bound on `countDate`, `YYYY-MM-DD`. */
+    countDateTo;
+    /**
+     * Matches against the expanded scope, not the roots the user picked, so
+     * filtering by a shelf finds the count that covers its whole aisle.
+     */
+    locationIds;
+};
+tslib.__decorate([
+    graphql.Field(() => String, { nullable: true }),
+    tslib.__metadata("design:type", String)
+], FindInventoryCountOrderArgs.prototype, "name", void 0);
+tslib.__decorate([
+    graphql.Field(() => [wmsModuleCore.InventoryCountStatus], { nullable: true }),
+    tslib.__metadata("design:type", Array)
+], FindInventoryCountOrderArgs.prototype, "statuses", void 0);
+tslib.__decorate([
+    graphql.Field(() => String, { nullable: true }),
+    tslib.__metadata("design:type", String)
+], FindInventoryCountOrderArgs.prototype, "createdBy", void 0);
+tslib.__decorate([
+    graphql.Field(() => String, { nullable: true }),
+    tslib.__metadata("design:type", String)
+], FindInventoryCountOrderArgs.prototype, "countDateFrom", void 0);
+tslib.__decorate([
+    graphql.Field(() => String, { nullable: true }),
+    tslib.__metadata("design:type", String)
+], FindInventoryCountOrderArgs.prototype, "countDateTo", void 0);
+tslib.__decorate([
+    graphql.Field(() => [graphql.ID], { nullable: true }),
+    tslib.__metadata("design:type", Array)
+], FindInventoryCountOrderArgs.prototype, "locationIds", void 0);
+FindInventoryCountOrderArgs = tslib.__decorate([
+    graphql.ArgsType()
+], FindInventoryCountOrderArgs);
+let CreateInventoryCountOrderArgs = class CreateInventoryCountOrderArgs {
+    name;
+    countDate;
+    /** Root locations; every descendant is pulled into scope automatically. */
+    locationIds;
+};
+tslib.__decorate([
+    graphql.Field(() => String),
+    tslib.__metadata("design:type", String)
+], CreateInventoryCountOrderArgs.prototype, "name", void 0);
+tslib.__decorate([
+    graphql.Field(() => String),
+    tslib.__metadata("design:type", String)
+], CreateInventoryCountOrderArgs.prototype, "countDate", void 0);
+tslib.__decorate([
+    graphql.Field(() => [graphql.ID]),
+    tslib.__metadata("design:type", Array)
+], CreateInventoryCountOrderArgs.prototype, "locationIds", void 0);
+CreateInventoryCountOrderArgs = tslib.__decorate([
+    graphql.ArgsType()
+], CreateInventoryCountOrderArgs);
+let UpdateInventoryCountOrderArgs = class UpdateInventoryCountOrderArgs {
+    id;
+    name;
+    countDate;
+    locationIds;
+};
+tslib.__decorate([
+    graphql.Field(() => graphql.ID),
+    tslib.__metadata("design:type", String)
+], UpdateInventoryCountOrderArgs.prototype, "id", void 0);
+tslib.__decorate([
+    graphql.Field(() => String, { nullable: true }),
+    tslib.__metadata("design:type", String)
+], UpdateInventoryCountOrderArgs.prototype, "name", void 0);
+tslib.__decorate([
+    graphql.Field(() => String, { nullable: true }),
+    tslib.__metadata("design:type", String)
+], UpdateInventoryCountOrderArgs.prototype, "countDate", void 0);
+tslib.__decorate([
+    graphql.Field(() => [graphql.ID], { nullable: true }),
+    tslib.__metadata("design:type", Array)
+], UpdateInventoryCountOrderArgs.prototype, "locationIds", void 0);
+UpdateInventoryCountOrderArgs = tslib.__decorate([
+    graphql.ArgsType()
+], UpdateInventoryCountOrderArgs);
+let CountInventoryItemInput = class CountInventoryItemInput {
+    itemId;
+    /** `null` clears the entry, putting the line back to "not counted". */
+    countedQuantity;
+    unitId;
+};
+tslib.__decorate([
+    graphql.Field(() => graphql.ID),
+    tslib.__metadata("design:type", String)
+], CountInventoryItemInput.prototype, "itemId", void 0);
+tslib.__decorate([
+    graphql.Field(() => graphql.Float, { nullable: true }),
+    tslib.__metadata("design:type", Object)
+], CountInventoryItemInput.prototype, "countedQuantity", void 0);
+tslib.__decorate([
+    graphql.Field(() => graphql.ID, { nullable: true }),
+    tslib.__metadata("design:type", Object)
+], CountInventoryItemInput.prototype, "unitId", void 0);
+CountInventoryItemInput = tslib.__decorate([
+    graphql.InputType()
+], CountInventoryItemInput);
+let CountInventoryArgs = class CountInventoryArgs {
+    id;
+    items;
+};
+tslib.__decorate([
+    graphql.Field(() => graphql.ID),
+    tslib.__metadata("design:type", String)
+], CountInventoryArgs.prototype, "id", void 0);
+tslib.__decorate([
+    graphql.Field(() => [CountInventoryItemInput]),
+    tslib.__metadata("design:type", Array)
+], CountInventoryArgs.prototype, "items", void 0);
+CountInventoryArgs = tslib.__decorate([
+    graphql.ArgsType()
+], CountInventoryArgs);
+let AddInventoryCountItemArgs = class AddInventoryCountItemArgs {
+    id;
+    materialId;
+    /** An existing batch key, or a new one — the batch is created on demand. */
+    batchKey;
+    locationId;
+    loaderId;
+    countedQuantity;
+    unitId;
+};
+tslib.__decorate([
+    graphql.Field(() => graphql.ID),
+    tslib.__metadata("design:type", String)
+], AddInventoryCountItemArgs.prototype, "id", void 0);
+tslib.__decorate([
+    graphql.Field(() => graphql.ID),
+    tslib.__metadata("design:type", String)
+], AddInventoryCountItemArgs.prototype, "materialId", void 0);
+tslib.__decorate([
+    graphql.Field(() => String),
+    tslib.__metadata("design:type", String)
+], AddInventoryCountItemArgs.prototype, "batchKey", void 0);
+tslib.__decorate([
+    graphql.Field(() => graphql.ID),
+    tslib.__metadata("design:type", String)
+], AddInventoryCountItemArgs.prototype, "locationId", void 0);
+tslib.__decorate([
+    graphql.Field(() => graphql.ID, { nullable: true }),
+    tslib.__metadata("design:type", Object)
+], AddInventoryCountItemArgs.prototype, "loaderId", void 0);
+tslib.__decorate([
+    graphql.Field(() => graphql.Float),
+    tslib.__metadata("design:type", Number)
+], AddInventoryCountItemArgs.prototype, "countedQuantity", void 0);
+tslib.__decorate([
+    graphql.Field(() => graphql.ID, { nullable: true }),
+    tslib.__metadata("design:type", Object)
+], AddInventoryCountItemArgs.prototype, "unitId", void 0);
+AddInventoryCountItemArgs = tslib.__decorate([
+    graphql.ArgsType()
+], AddInventoryCountItemArgs);
+let RemoveInventoryCountItemArgs = class RemoveInventoryCountItemArgs {
+    id;
+    itemId;
+};
+tslib.__decorate([
+    graphql.Field(() => graphql.ID),
+    tslib.__metadata("design:type", String)
+], RemoveInventoryCountItemArgs.prototype, "id", void 0);
+tslib.__decorate([
+    graphql.Field(() => graphql.ID),
+    tslib.__metadata("design:type", String)
+], RemoveInventoryCountItemArgs.prototype, "itemId", void 0);
+RemoveInventoryCountItemArgs = tslib.__decorate([
+    graphql.ArgsType()
+], RemoveInventoryCountItemArgs);
+let InventoryCountOrderIdArgs = class InventoryCountOrderIdArgs {
+    id;
+};
+tslib.__decorate([
+    graphql.Field(() => graphql.ID),
+    tslib.__metadata("design:type", String)
+], InventoryCountOrderIdArgs.prototype, "id", void 0);
+InventoryCountOrderIdArgs = tslib.__decorate([
+    graphql.ArgsType()
+], InventoryCountOrderIdArgs);
+
+let InventoryCountOrderQuery = class InventoryCountOrderQuery {
+    inventoryCountOrderService;
+    constructor(inventoryCountOrderService) {
+        this.inventoryCountOrderService = inventoryCountOrderService;
+    }
+    async inventoryCountOrders(args) {
+        const [items, total] = await this.inventoryCountOrderService.findMany(args);
+        return { items, total };
+    }
+    async inventoryCountOrder({ id }) {
+        return this.inventoryCountOrderService.findOne(id);
+    }
+};
+tslib.__decorate([
+    graphql.Query(() => InventoryCountOrders),
+    WmsOperation({ resource: 'inventory-count-order', action: 'read' }),
+    tslib.__param(0, graphql.Args()),
+    tslib.__metadata("design:type", Function),
+    tslib.__metadata("design:paramtypes", [FindInventoryCountOrderArgs]),
+    tslib.__metadata("design:returntype", Promise)
+], InventoryCountOrderQuery.prototype, "inventoryCountOrders", null);
+tslib.__decorate([
+    graphql.Query(() => InventoryCountOrderDto),
+    WmsOperation({ resource: 'inventory-count-order', action: 'read' }),
+    tslib.__param(0, graphql.Args()),
+    tslib.__metadata("design:type", Function),
+    tslib.__metadata("design:paramtypes", [InventoryCountOrderIdArgs]),
+    tslib.__metadata("design:returntype", Promise)
+], InventoryCountOrderQuery.prototype, "inventoryCountOrder", null);
+InventoryCountOrderQuery = tslib.__decorate([
+    common.Injectable(),
+    tslib.__metadata("design:paramtypes", [wmsModuleCore.InventoryCountOrderService])
+], InventoryCountOrderQuery);
+
+let InventoryCountOrderMutation = class InventoryCountOrderMutation {
+    inventoryCountOrderService;
+    constructor(inventoryCountOrderService) {
+        this.inventoryCountOrderService = inventoryCountOrderService;
+    }
+    async createInventoryCountOrder(args) {
+        return this.inventoryCountOrderService.create(args);
+    }
+    async updateInventoryCountOrder({ id, ...input }) {
+        return this.inventoryCountOrderService.update(id, input);
+    }
+    async startInventoryCount({ id }) {
+        return this.inventoryCountOrderService.start(id);
+    }
+    /** "暫存結果" — record what was counted without touching stock. */
+    async countInventory({ id, items }) {
+        return this.inventoryCountOrderService.count(id, items.map((item) => ({
+            itemId: item.itemId,
+            countedQuantity: item.countedQuantity ?? null,
+            unitId: item.unitId,
+        })));
+    }
+    async addInventoryCountItem({ id, ...input }) {
+        return this.inventoryCountOrderService.addItem(id, input);
+    }
+    async removeInventoryCountItem({ id, itemId }) {
+        return this.inventoryCountOrderService.removeItem(id, itemId);
+    }
+    /** "清空重填" — discard the counting, keep the lock and the status. */
+    async resetInventoryCount({ id }) {
+        return this.inventoryCountOrderService.reset(id);
+    }
+    async cancelInventoryCount({ id }) {
+        return this.inventoryCountOrderService.cancel(id);
+    }
+    /** "執行盤差" — the only mutation here that changes stock. */
+    async settleInventoryCount({ id }) {
+        return this.inventoryCountOrderService.settle(id);
+    }
+};
+tslib.__decorate([
+    graphql.Mutation(() => InventoryCountOrderDto),
+    WmsOperation({ resource: 'inventory-count-order', action: 'create' }),
+    WmsMutationEvent({ event: 'inventory-count-order.created' }),
+    tslib.__param(0, graphql.Args()),
+    tslib.__metadata("design:type", Function),
+    tslib.__metadata("design:paramtypes", [CreateInventoryCountOrderArgs]),
+    tslib.__metadata("design:returntype", Promise)
+], InventoryCountOrderMutation.prototype, "createInventoryCountOrder", null);
+tslib.__decorate([
+    graphql.Mutation(() => InventoryCountOrderDto),
+    WmsOperation({ resource: 'inventory-count-order', action: 'update' }),
+    WmsMutationEvent({ event: 'inventory-count-order.updated' }),
+    tslib.__param(0, graphql.Args()),
+    tslib.__metadata("design:type", Function),
+    tslib.__metadata("design:paramtypes", [UpdateInventoryCountOrderArgs]),
+    tslib.__metadata("design:returntype", Promise)
+], InventoryCountOrderMutation.prototype, "updateInventoryCountOrder", null);
+tslib.__decorate([
+    graphql.Mutation(() => InventoryCountOrderDto),
+    WmsOperation({ resource: 'inventory-count-order', action: 'start' }),
+    WmsMutationEvent({ event: 'inventory-count-order.started' }),
+    tslib.__param(0, graphql.Args()),
+    tslib.__metadata("design:type", Function),
+    tslib.__metadata("design:paramtypes", [InventoryCountOrderIdArgs]),
+    tslib.__metadata("design:returntype", Promise)
+], InventoryCountOrderMutation.prototype, "startInventoryCount", null);
+tslib.__decorate([
+    graphql.Mutation(() => InventoryCountOrderDto),
+    WmsOperation({ resource: 'inventory-count-order', action: 'count' }),
+    WmsMutationEvent({ event: 'inventory-count-order.counted' }),
+    tslib.__param(0, graphql.Args()),
+    tslib.__metadata("design:type", Function),
+    tslib.__metadata("design:paramtypes", [CountInventoryArgs]),
+    tslib.__metadata("design:returntype", Promise)
+], InventoryCountOrderMutation.prototype, "countInventory", null);
+tslib.__decorate([
+    graphql.Mutation(() => InventoryCountOrderItemDto),
+    WmsOperation({ resource: 'inventory-count-order', action: 'add-item' }),
+    WmsMutationEvent({ event: 'inventory-count-order.updated' }),
+    tslib.__param(0, graphql.Args()),
+    tslib.__metadata("design:type", Function),
+    tslib.__metadata("design:paramtypes", [AddInventoryCountItemArgs]),
+    tslib.__metadata("design:returntype", Promise)
+], InventoryCountOrderMutation.prototype, "addInventoryCountItem", null);
+tslib.__decorate([
+    graphql.Mutation(() => InventoryCountOrderDto),
+    WmsOperation({ resource: 'inventory-count-order', action: 'remove-item' }),
+    WmsMutationEvent({ event: 'inventory-count-order.updated' }),
+    tslib.__param(0, graphql.Args()),
+    tslib.__metadata("design:type", Function),
+    tslib.__metadata("design:paramtypes", [RemoveInventoryCountItemArgs]),
+    tslib.__metadata("design:returntype", Promise)
+], InventoryCountOrderMutation.prototype, "removeInventoryCountItem", null);
+tslib.__decorate([
+    graphql.Mutation(() => InventoryCountOrderDto),
+    WmsOperation({ resource: 'inventory-count-order', action: 'reset' }),
+    WmsMutationEvent({ event: 'inventory-count-order.reset' }),
+    tslib.__param(0, graphql.Args()),
+    tslib.__metadata("design:type", Function),
+    tslib.__metadata("design:paramtypes", [InventoryCountOrderIdArgs]),
+    tslib.__metadata("design:returntype", Promise)
+], InventoryCountOrderMutation.prototype, "resetInventoryCount", null);
+tslib.__decorate([
+    graphql.Mutation(() => InventoryCountOrderDto),
+    WmsOperation({ resource: 'inventory-count-order', action: 'cancel' }),
+    WmsMutationEvent({ event: 'inventory-count-order.cancelled' }),
+    tslib.__param(0, graphql.Args()),
+    tslib.__metadata("design:type", Function),
+    tslib.__metadata("design:paramtypes", [InventoryCountOrderIdArgs]),
+    tslib.__metadata("design:returntype", Promise)
+], InventoryCountOrderMutation.prototype, "cancelInventoryCount", null);
+tslib.__decorate([
+    graphql.Mutation(() => InventoryCountOrderDto),
+    WmsOperation({ resource: 'inventory-count-order', action: 'settle' }),
+    WmsMutationEvent({ event: 'inventory-count-order.settled' }),
+    tslib.__param(0, graphql.Args()),
+    tslib.__metadata("design:type", Function),
+    tslib.__metadata("design:paramtypes", [InventoryCountOrderIdArgs]),
+    tslib.__metadata("design:returntype", Promise)
+], InventoryCountOrderMutation.prototype, "settleInventoryCount", null);
+InventoryCountOrderMutation = tslib.__decorate([
+    common.Injectable(),
+    tslib.__metadata("design:paramtypes", [wmsModuleCore.InventoryCountOrderService])
+], InventoryCountOrderMutation);
+
+let InventoryCountOrderResolver = class InventoryCountOrderResolver {
+    entities;
+    constructor(entities) {
+        this.entities = entities;
+    }
+    items({ id }, { loaders }) {
+        return loaders.batchMany.load({
+            __entity: wmsModuleCore.InventoryCountOrderItemEntityClass,
+            __from: { orderId: id },
+        });
+    }
+    /**
+     * The locations the user picked.
+     *
+     * Only the roots: the scope table also holds every descendant the backend
+     * expanded into, and listing a whole aisle's shelves as chips would bury the
+     * one thing the operator actually chose. The expansion still exists in the
+     * database — it is what the lock reads — it just is not this field.
+     */
+    async locations({ id }, { loaders }) {
+        const scope = (await loaders.batchMany.load({
+            __entity: wmsModuleCore.InventoryCountOrderLocationEntityClass,
+            __from: { orderId: id },
+        }));
+        // The join rows carry `locationId`, not a loaded `location` relation, so
+        // each one has to go back through the location DataLoader. Returning
+        // `row.location` directly yields `undefined`, and the non-nullable list then
+        // fails the whole query with "Cannot return null for non-nullable field".
+        return Promise.all(scope
+            .filter(({ isRoot }) => isRoot)
+            .map(({ locationId }) => loaders.batchSingle.load({
+            __entity: this.entities.location,
+            __from: { id: locationId },
+        })));
+    }
+};
+tslib.__decorate([
+    graphql.ResolveField(() => [InventoryCountOrderItemDto]),
+    tslib.__param(0, graphql.Parent()),
+    tslib.__param(1, graphql.Context()),
+    tslib.__metadata("design:type", Function),
+    tslib.__metadata("design:paramtypes", [InventoryCountOrderDto, Object]),
+    tslib.__metadata("design:returntype", Promise)
+], InventoryCountOrderResolver.prototype, "items", 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", [InventoryCountOrderDto, Object]),
+    tslib.__metadata("design:returntype", Promise)
+], InventoryCountOrderResolver.prototype, "locations", null);
+InventoryCountOrderResolver = tslib.__decorate([
+    graphql.Resolver(() => InventoryCountOrderDto),
+    tslib.__metadata("design:paramtypes", [wmsModuleCore.WmsEntities])
+], InventoryCountOrderResolver);
+let InventoryCountOrderItemResolver = class InventoryCountOrderItemResolver {
+    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`.
+     */
+    constructor(entities) {
+        this.entities = entities;
+    }
+    material({ materialId }, { loaders }) {
+        return loaders.batchSingle.load({
+            __entity: this.entities.material,
+            __from: { id: materialId },
+        });
+    }
+    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 },
+        });
+    }
+    location({ locationId }, { loaders }) {
+        if (!locationId) {
+            return null;
+        }
+        return loaders.batchSingle.load({
+            __entity: this.entities.location,
+            __from: { id: locationId },
+        });
+    }
+    loader({ loaderId }, { loaders }) {
+        if (!loaderId) {
+            return null;
+        }
+        return loaders.batchSingle.load({
+            __entity: wmsModuleCore.LoadersEntityClass,
+            __from: { id: loaderId },
+        });
+    }
+};
+tslib.__decorate([
+    graphql.ResolveField(() => MaterialDto),
+    tslib.__param(0, graphql.Parent()),
+    tslib.__param(1, graphql.Context()),
+    tslib.__metadata("design:type", Function),
+    tslib.__metadata("design:paramtypes", [InventoryCountOrderItemDto, Object]),
+    tslib.__metadata("design:returntype", Promise)
+], InventoryCountOrderItemResolver.prototype, "material", 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", [InventoryCountOrderItemDto, Object]),
+    tslib.__metadata("design:returntype", Promise)
+], InventoryCountOrderItemResolver.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", [InventoryCountOrderItemDto, Object]),
+    tslib.__metadata("design:returntype", Object)
+], InventoryCountOrderItemResolver.prototype, "location", 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", [InventoryCountOrderItemDto, Object]),
+    tslib.__metadata("design:returntype", Object)
+], InventoryCountOrderItemResolver.prototype, "loader", null);
+InventoryCountOrderItemResolver = tslib.__decorate([
+    graphql.Resolver(() => InventoryCountOrderItemDto),
+    tslib.__metadata("design:paramtypes", [wmsModuleCore.WmsEntities])
+], InventoryCountOrderItemResolver);
+
 var WmsModuleGraphqlModule_1;
 const exportDependencies = [
     UnitQuery,
@@ -6732,10 +7492,23 @@ const exportDependencies = [
     QualityInspectionOrderMutation,
     WarehouseMapDataQuery,
     MapRangeUnionResolver,
+    InventoryCountOrderQuery,
+    InventoryCountOrderMutation,
+    InventoryCountOrderResolver,
+    InventoryCountOrderItemResolver,
 ];
 exports.WmsModuleGraphqlModule = WmsModuleGraphqlModule_1 = class WmsModuleGraphqlModule {
     static forRootAsync(options) {
-        const { authChecker, beforeHooks, afterListeners, actorExtractor, eventEmitterBridge, ...coreOptions } = options;
+        const { authChecker, beforeHooks, afterListeners, actorExtractor, eventEmitterBridge, enabledOperations, disabledOperations, disabledFields, ...coreOptions } = options;
+        // Must run before `GraphQLModule` builds the schema. `forRootAsync` is
+        // called while `AppModule` is still being defined, so this is the earliest
+        // point at which the deployment's switches are known — and it is early
+        // enough: the schema is not built until the app bootstraps.
+        pruneDisabledOperations(exportDependencies, {
+            enabledOperations,
+            disabledOperations,
+            disabledFields,
+        });
         // coreOptions still carries `enrichStockEvents`, forwarded to the core module.
         const coreModule = wmsModuleCore.WmsModuleCoreModule.forRootAsync(coreOptions);
         const authOptions = { authChecker };
@@ -6770,6 +7543,10 @@ exports.WmsModuleGraphqlModule = WmsModuleGraphqlModule_1 = tslib.__decorate([
     })
 ], exports.WmsModuleGraphqlModule);
 
+Object.defineProperty(exports, "WMS_OPERATION_NAMES", {
+    enumerable: true,
+    get: function () { return wmsModuleCore.WMS_OPERATION_NAMES; }
+});
 exports.HOST_SKIP_METADATA_KEY = HOST_SKIP_METADATA_KEY;
 exports.WMS_AUTH_OPTIONS = WMS_AUTH_OPTIONS;
 exports.WMS_MUTATION_EVENT_METADATA = WMS_MUTATION_EVENT_METADATA;
@@ -6777,3 +7554,4 @@ exports.WMS_OPERATION_METADATA = WMS_OPERATION_METADATA;
 exports.WmsMutationEvent = WmsMutationEvent;
 exports.WmsOperation = WmsOperation;
 exports.createWmsLoaders = createWmsLoaders;
+exports.pruneDisabledOperations = pruneDisabledOperations;