@rytass/wms-module-graphql 0.8.0 → 0.9.0

package/lib/mutations/inventory-count-order.mutation.js

@@ -0,0 +1,138 @@
+import { __decorate, __param, __metadata } from 'tslib';
+import { Injectable } from '@nestjs/common';
+import { Mutation, Args } from '@nestjs/graphql';
+import { InventoryCountOrderService } from '@rytass/wms-module-core';
+import { InventoryCountOrderDto, InventoryCountOrderItemDto } from '../dto/inventory-count-order.dto.js';
+import { CreateInventoryCountOrderArgs, UpdateInventoryCountOrderArgs, InventoryCountOrderIdArgs, CountInventoryArgs, AddInventoryCountItemArgs, RemoveInventoryCountItemArgs } from '../inputs/inventory-count-order.args.js';
+import '../auth/wms-auth.guard.js';
+import { WmsOperation } from '../auth/wms-operation.decorator.js';
+import { WmsMutationEvent } from '../events/wms-mutation-event.decorator.js';
+import '../events/wms-mutation.interceptor.js';
+
+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);
+    }
+};
+__decorate([
+    Mutation(() => InventoryCountOrderDto),
+    WmsOperation({ resource: 'inventory-count-order', action: 'create' }),
+    WmsMutationEvent({ event: 'inventory-count-order.created' }),
+    __param(0, Args()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [CreateInventoryCountOrderArgs]),
+    __metadata("design:returntype", Promise)
+], InventoryCountOrderMutation.prototype, "createInventoryCountOrder", null);
+__decorate([
+    Mutation(() => InventoryCountOrderDto),
+    WmsOperation({ resource: 'inventory-count-order', action: 'update' }),
+    WmsMutationEvent({ event: 'inventory-count-order.updated' }),
+    __param(0, Args()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [UpdateInventoryCountOrderArgs]),
+    __metadata("design:returntype", Promise)
+], InventoryCountOrderMutation.prototype, "updateInventoryCountOrder", null);
+__decorate([
+    Mutation(() => InventoryCountOrderDto),
+    WmsOperation({ resource: 'inventory-count-order', action: 'start' }),
+    WmsMutationEvent({ event: 'inventory-count-order.started' }),
+    __param(0, Args()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [InventoryCountOrderIdArgs]),
+    __metadata("design:returntype", Promise)
+], InventoryCountOrderMutation.prototype, "startInventoryCount", null);
+__decorate([
+    Mutation(() => InventoryCountOrderDto),
+    WmsOperation({ resource: 'inventory-count-order', action: 'count' }),
+    WmsMutationEvent({ event: 'inventory-count-order.counted' }),
+    __param(0, Args()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [CountInventoryArgs]),
+    __metadata("design:returntype", Promise)
+], InventoryCountOrderMutation.prototype, "countInventory", null);
+__decorate([
+    Mutation(() => InventoryCountOrderItemDto),
+    WmsOperation({ resource: 'inventory-count-order', action: 'add-item' }),
+    WmsMutationEvent({ event: 'inventory-count-order.updated' }),
+    __param(0, Args()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [AddInventoryCountItemArgs]),
+    __metadata("design:returntype", Promise)
+], InventoryCountOrderMutation.prototype, "addInventoryCountItem", null);
+__decorate([
+    Mutation(() => InventoryCountOrderDto),
+    WmsOperation({ resource: 'inventory-count-order', action: 'remove-item' }),
+    WmsMutationEvent({ event: 'inventory-count-order.updated' }),
+    __param(0, Args()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [RemoveInventoryCountItemArgs]),
+    __metadata("design:returntype", Promise)
+], InventoryCountOrderMutation.prototype, "removeInventoryCountItem", null);
+__decorate([
+    Mutation(() => InventoryCountOrderDto),
+    WmsOperation({ resource: 'inventory-count-order', action: 'reset' }),
+    WmsMutationEvent({ event: 'inventory-count-order.reset' }),
+    __param(0, Args()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [InventoryCountOrderIdArgs]),
+    __metadata("design:returntype", Promise)
+], InventoryCountOrderMutation.prototype, "resetInventoryCount", null);
+__decorate([
+    Mutation(() => InventoryCountOrderDto),
+    WmsOperation({ resource: 'inventory-count-order', action: 'cancel' }),
+    WmsMutationEvent({ event: 'inventory-count-order.cancelled' }),
+    __param(0, Args()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [InventoryCountOrderIdArgs]),
+    __metadata("design:returntype", Promise)
+], InventoryCountOrderMutation.prototype, "cancelInventoryCount", null);
+__decorate([
+    Mutation(() => InventoryCountOrderDto),
+    WmsOperation({ resource: 'inventory-count-order', action: 'settle' }),
+    WmsMutationEvent({ event: 'inventory-count-order.settled' }),
+    __param(0, Args()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [InventoryCountOrderIdArgs]),
+    __metadata("design:returntype", Promise)
+], InventoryCountOrderMutation.prototype, "settleInventoryCount", null);
+InventoryCountOrderMutation = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [InventoryCountOrderService])
+], InventoryCountOrderMutation);
+
+export { InventoryCountOrderMutation };

package/lib/mutations/loader.mutation.js

@@ -25,6 +25,7 @@ import '../dto/scrape-order.dto.js';
 import '../dto/scrape-order-item.dto.js';
 import '../dto/quality-inspection-order.dto.js';
 import '../dto/quality-inspection-order-item.dto.js';
+import '../dto/inventory-count-order.dto.js';
 import { Mutation, Args } from '@nestjs/graphql';
 import { CreateLoaderTypeArgs, UpdateLoaderTypeArgs } from '../inputs/create-loader-type.args.js';
 import { CreateLoaderArgs, CreateLoadersArgs, UpdateLoaderArgs } from '../inputs/create-loader.args.js';

package/lib/mutations/material.mutation.js

@@ -25,6 +25,7 @@ import '../dto/scrape-order.dto.js';
 import '../dto/scrape-order-item.dto.js';
 import '../dto/quality-inspection-order.dto.js';
 import '../dto/quality-inspection-order-item.dto.js';
+import '../dto/inventory-count-order.dto.js';
 import { CreateMaterialArgs, UpdateMaterialArgs } from '../inputs/create-material.args.js';
 import { MaterialService } from '@rytass/wms-module-core';
 import '../auth/wms-auth.guard.js';

package/lib/mutations/receive-inventory-order.mutation.js

@@ -26,6 +26,7 @@ import '../dto/scrape-order.dto.js';
 import '../dto/scrape-order-item.dto.js';
 import '../dto/quality-inspection-order.dto.js';
 import '../dto/quality-inspection-order-item.dto.js';
+import '../dto/inventory-count-order.dto.js';
 import { CreateReceiveInventoryOrderArgs, UpdateReceiveInventoryOrderArgs } from '../inputs/create-receive-inventory-order.args.js';
 import { DataSource } from 'typeorm';
 import { ReceiveOrderArgs } from '../inputs/receive-order.args.js';

package/lib/mutations/ship-inventory-order.mutation.js

@@ -25,6 +25,7 @@ import '../dto/scrape-order.dto.js';
 import '../dto/scrape-order-item.dto.js';
 import '../dto/quality-inspection-order.dto.js';
 import '../dto/quality-inspection-order-item.dto.js';
+import '../dto/inventory-count-order.dto.js';
 import { Mutation, Args } from '@nestjs/graphql';
 import { CreateShipInventoryOrderArgs, UpdateShipInventoryOrderArgs } from '../inputs/create-ship-inventory-order.args.js';
 import { ShipOrderArgs } from '../inputs/ship-order.args.js';

package/lib/queries/inventory-count-order.query.d.ts

@@ -0,0 +1,9 @@
+import { InventoryCountOrderService } from '@rytass/wms-module-core';
+import { InventoryCountOrderDto, InventoryCountOrders } from '../dto/inventory-count-order.dto';
+import { FindInventoryCountOrderArgs, InventoryCountOrderIdArgs } from '../inputs/inventory-count-order.args';
+export declare class InventoryCountOrderQuery {
+    private readonly inventoryCountOrderService;
+    constructor(inventoryCountOrderService: InventoryCountOrderService);
+    inventoryCountOrders(args: FindInventoryCountOrderArgs): Promise<InventoryCountOrders>;
+    inventoryCountOrder({ id }: InventoryCountOrderIdArgs): Promise<InventoryCountOrderDto>;
+}

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

@@ -0,0 +1,44 @@
+import { __decorate, __param, __metadata } from 'tslib';
+import { Injectable } from '@nestjs/common';
+import { Query, Args } from '@nestjs/graphql';
+import { InventoryCountOrderService } from '@rytass/wms-module-core';
+import { InventoryCountOrders, InventoryCountOrderDto } from '../dto/inventory-count-order.dto.js';
+import { FindInventoryCountOrderArgs, InventoryCountOrderIdArgs } from '../inputs/inventory-count-order.args.js';
+import '../auth/wms-auth.guard.js';
+import { WmsOperation } from '../auth/wms-operation.decorator.js';
+
+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);
+    }
+};
+__decorate([
+    Query(() => InventoryCountOrders),
+    WmsOperation({ resource: 'inventory-count-order', action: 'read' }),
+    __param(0, Args()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [FindInventoryCountOrderArgs]),
+    __metadata("design:returntype", Promise)
+], InventoryCountOrderQuery.prototype, "inventoryCountOrders", null);
+__decorate([
+    Query(() => InventoryCountOrderDto),
+    WmsOperation({ resource: 'inventory-count-order', action: 'read' }),
+    __param(0, Args()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [InventoryCountOrderIdArgs]),
+    __metadata("design:returntype", Promise)
+], InventoryCountOrderQuery.prototype, "inventoryCountOrder", null);
+InventoryCountOrderQuery = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [InventoryCountOrderService])
+], InventoryCountOrderQuery);
+
+export { InventoryCountOrderQuery };

package/lib/queries/loader.query.js

@@ -26,6 +26,7 @@ import '../dto/scrape-order.dto.js';
 import '../dto/scrape-order-item.dto.js';
 import '../dto/quality-inspection-order.dto.js';
 import '../dto/quality-inspection-order-item.dto.js';
+import '../dto/inventory-count-order.dto.js';
 import { FindLoaderArgs } from '../inputs/find-loader.args.js';
 import { FindLoaderTypeArgs } from '../inputs/find-loader-type.args.js';
 import { LoaderUnitDto, LoaderUnit } from '../dto/loader-unit.dto.js';

package/lib/queries/material.query.js

@@ -25,6 +25,7 @@ import '../dto/scrape-order.dto.js';
 import '../dto/scrape-order-item.dto.js';
 import '../dto/quality-inspection-order.dto.js';
 import '../dto/quality-inspection-order-item.dto.js';
+import '../dto/inventory-count-order.dto.js';
 import { MaterialService } from '@rytass/wms-module-core';
 import { FindMaterialArgs } from '../inputs/find-material.args.js';
 import '../auth/wms-auth.guard.js';

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

@@ -26,6 +26,7 @@ import '../dto/scrape-order.dto.js';
 import '../dto/scrape-order-item.dto.js';
 import '../dto/quality-inspection-order.dto.js';
 import '../dto/quality-inspection-order-item.dto.js';
+import '../dto/inventory-count-order.dto.js';
 import { FindReceiveInventoryOrderArgs } from '../inputs/find-receive-inventory-order.args.js';
 import '../auth/wms-auth.guard.js';
 import { WmsOperation } from '../auth/wms-operation.decorator.js';

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

@@ -26,6 +26,7 @@ import '../dto/scrape-order.dto.js';
 import '../dto/scrape-order-item.dto.js';
 import '../dto/quality-inspection-order.dto.js';
 import '../dto/quality-inspection-order-item.dto.js';
+import '../dto/inventory-count-order.dto.js';
 import { FindShipInventoryOrderArgs } from '../inputs/find-ship-inventory-order.args.js';
 import '../auth/wms-auth.guard.js';
 import { WmsOperation } from '../auth/wms-operation.decorator.js';

package/lib/queries/stock.query.js

@@ -26,6 +26,7 @@ import '../dto/scrape-order.dto.js';
 import '../dto/scrape-order-item.dto.js';
 import '../dto/quality-inspection-order.dto.js';
 import '../dto/quality-inspection-order-item.dto.js';
+import '../dto/inventory-count-order.dto.js';
 import { FindStockArgs } from '../inputs/find-stock.args.js';
 import '../auth/wms-auth.guard.js';
 import { WmsOperation } from '../auth/wms-operation.decorator.js';

package/lib/registry/index.d.ts

@@ -0,0 +1 @@
+export { pruneDisabledOperations, resolveDisabled, type PrunedOperations, type WmsOperationRegistrationOptions, } from './operation-registry';

package/lib/registry/operation-registry.d.ts

@@ -0,0 +1,59 @@
+import { Type } from '@nestjs/common';
+import type { WmsOperationName } from '@rytass/wms-module-core';
+/**
+ * Deployment-level switches deciding which root operations get registered.
+ *
+ * `authChecker` and `beforeHooks` can already *refuse* an operation, but the
+ * resolver stays in the compiled schema — so introspection, the consumer's
+ * frontend codegen and any security audit still see a mutation that is
+ * guaranteed to fail. These options remove it instead.
+ */
+export interface WmsOperationRegistrationOptions {
+    /**
+     * Allow-list of `${resource}:${action}` names. Only these are registered.
+     * Mutually exclusive with {@link disabledOperations}.
+     */
+    readonly enabledOperations?: readonly WmsOperationName[];
+    /** Deny-list of `${resource}:${action}` names. */
+    readonly disabledOperations?: readonly WmsOperationName[];
+    /**
+     * Escape hatch by GraphQL field name, for when a requirement is too coarse.
+     * Several queries share one requirement — `loader:read` alone covers 6 fields
+     * — so disabling the name would take all of them. Name the field instead.
+     */
+    readonly disabledFields?: readonly string[];
+}
+/** What a pruning pass removed, keyed by root type. */
+export interface PrunedOperations {
+    readonly queries: readonly string[];
+    readonly mutations: readonly string[];
+}
+export declare function resolveDisabled(options: WmsOperationRegistrationOptions): {
+    readonly hasSwitches: boolean;
+    readonly isOperationDisabled: (name: string) => boolean;
+    readonly disabledFields: ReadonlySet<string>;
+};
+/**
+ * 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.
+ */
+export declare function pruneDisabledOperations(resolverClasses: readonly Type<unknown>[], options: WmsOperationRegistrationOptions): PrunedOperations;

package/lib/registry/operation-registry.js

@@ -0,0 +1,136 @@
+import { RESOLVER_TYPE_METADATA, TypeMetadataStorage, RESOLVER_NAME_METADATA } from '@nestjs/graphql';
+import { WMS_OPERATION_METADATA } from '../auth/wms-auth.types.js';
+
+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 = 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(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(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 };
+}
+
+export { pruneDisabledOperations, resolveDisabled };

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

@@ -24,6 +24,7 @@ import '../dto/scrape-order.dto.js';
 import '../dto/scrape-order-item.dto.js';
 import '../dto/quality-inspection-order.dto.js';
 import '../dto/quality-inspection-order-item.dto.js';
+import '../dto/inventory-count-order.dto.js';
 import { StockService, WmsEntities, BatchGroupEntityClass, LoadersEntityClass } from '@rytass/wms-module-core';
 import { BatchDto } from '../dto/batch.dto.js';
 import { LocationDto } from '../dto/location.dto.js';

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

@@ -24,6 +24,7 @@ import '../dto/scrape-order.dto.js';
 import '../dto/scrape-order-item.dto.js';
 import '../dto/quality-inspection-order.dto.js';
 import '../dto/quality-inspection-order-item.dto.js';
+import '../dto/inventory-count-order.dto.js';
 import { StockEntityClass, WmsEntities, BatchGroupEntityClass } from '@rytass/wms-module-core';
 import { LocationDto } from '../dto/location.dto.js';
 import { BatchDto } from '../dto/batch.dto.js';

package/lib/resolvers/inventory-count-order.resolver.d.ts

@@ -0,0 +1,34 @@
+import { BatchEntityClass, InventoryCountOrderItemEntityClass, InventoryCountOrderLocationEntityClass, LoadersEntityClass, LocationEntityClass, MaterialEntityClass, WmsEntities } from '@rytass/wms-module-core';
+import { InventoryCountOrderDto, InventoryCountOrderItemDto } from '../dto/inventory-count-order.dto';
+import { BatchDto } from '../dto/batch.dto';
+import { LoaderDto } from '../dto/loader.dto';
+import { LocationDto } from '../dto/location.dto';
+import { MaterialDto } from '../dto/material.dto';
+import { type LoaderType } from '../helpers';
+export declare class InventoryCountOrderResolver {
+    private readonly entities;
+    constructor(entities: WmsEntities);
+    items({ id }: InventoryCountOrderDto, { loaders }: LoaderType<InventoryCountOrderItemEntityClass>): Promise<InventoryCountOrderItemDto[]>;
+    /**
+     * 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.
+     */
+    locations({ id }: InventoryCountOrderDto, { loaders }: LoaderType<InventoryCountOrderLocationEntityClass>): Promise<LocationDto[]>;
+}
+export declare class InventoryCountOrderItemResolver {
+    private readonly entities;
+    /**
+     * The configured entities, not the built-in classes: `__entity` decides which
+     * repository the DataLoader opens, so it has to follow whatever the consumer
+     * passed to `WMSBaseModuleOptions`.
+     */
+    constructor(entities: WmsEntities);
+    material({ materialId }: InventoryCountOrderItemDto, { loaders }: LoaderType<MaterialEntityClass>): Promise<MaterialDto>;
+    batch({ batchId }: InventoryCountOrderItemDto, { loaders }: LoaderType<BatchEntityClass>): Promise<BatchDto>;
+    location({ locationId }: InventoryCountOrderItemDto, { loaders }: LoaderType<LocationEntityClass>): Promise<LocationDto> | null;
+    loader({ loaderId }: InventoryCountOrderItemDto, { loaders }: LoaderType<LoadersEntityClass>): Promise<LoaderDto> | null;
+}