@rytass/wms-module-graphql 0.11.0 → 0.12.0

package/lib/queries/stock.query.js

@@ -1,116 +0,0 @@
-import { __decorate, __param, __metadata } from 'tslib';
-import { Injectable } from '@nestjs/common';
-import { Query, Args, ID } from '@nestjs/graphql';
-import { StockService } from '@rytass/wms-module-core';
-import '../dto/loader-type.dto.js';
-import '../dto/loader.dto.js';
-import { Materials } from '../dto/material.dto.js';
-import '../dto/material-unit.dto.js';
-import { StockDto, Stocks, AggregatedStocks, ChangeLogs } from '../dto/stock.dto.js';
-import '../dto/sale-order.dto.js';
-import '../dto/receive-inventory-order.dto.js';
-import '../dto/receive-inventory-order-item.dto.js';
-import '../dto/ship-inventory-order.dto.js';
-import '../dto/ship-inventory-order-item.dto.js';
-import '../dto/hold-inventory-order.dto.js';
-import '../dto/hold-inventory-order-item.dto.js';
-import '../dto/allocate-inventory-order.dto.js';
-import '../dto/allocate-inventory-order-item.dto.js';
-import '../dto/transfer-order.dto.js';
-import '../dto/transfer-order-item.dto.js';
-import '../dto/transfer-customer-order.dto.js';
-import '../dto/transfer-customer-order-item.dto.js';
-import '../dto/transfer-vendor-order.dto.js';
-import '../dto/transfer-vendor-order-item.dto.js';
-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 '../dto/consumption-order.dto.js';
-import '../dto/consumption-order-item.dto.js';
-import '../dto/order-reference.dto.js';
-import { FindStockArgs } from '../inputs/find-stock.args.js';
-import '../auth/wms-auth.guard.js';
-import { WmsOperation } from '../auth/wms-operation.decorator.js';
-
-let StockQuery = class StockQuery {
-    stockService;
-    constructor(stockService) {
-        this.stockService = stockService;
-    }
-    stock(id) {
-        return this.stockService.stockRepository.findOneByOrFail({ id });
-    }
-    async stocks(args) {
-        const [items, total] = await this.stockService.findMany(args);
-        return { items, total };
-    }
-    async stocksGroupedByMaterial(args) {
-        const [items, total] = await this.stockService.findManyGroupedByMaterialId(args);
-        return { items, total };
-    }
-    async aggregatedStocks(args) {
-        const [items, total] = await this.stockService.findAggregatedStocks({
-            ...args,
-            aggregatedKeys: args.ids?.length ? args.ids : [],
-        });
-        return { items, total };
-    }
-    async changeLogs(args) {
-        const [items, total] = await this.stockService.findChangeLogs(args);
-        return {
-            items: items.map((item) => ({
-                ...item,
-                quantity: Math.abs(item.quantity),
-            })),
-            total,
-        };
-    }
-};
-__decorate([
-    Query(() => StockDto),
-    WmsOperation({ resource: 'stock', action: 'read' }),
-    __param(0, Args('id', { type: () => ID })),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String]),
-    __metadata("design:returntype", Promise)
-], StockQuery.prototype, "stock", null);
-__decorate([
-    Query(() => Stocks),
-    WmsOperation({ resource: 'stock', action: 'read' }),
-    __param(0, Args()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [FindStockArgs]),
-    __metadata("design:returntype", Promise)
-], StockQuery.prototype, "stocks", null);
-__decorate([
-    Query(() => Materials),
-    WmsOperation({ resource: 'stock', action: 'read' }),
-    __param(0, Args()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [FindStockArgs]),
-    __metadata("design:returntype", Promise)
-], StockQuery.prototype, "stocksGroupedByMaterial", null);
-__decorate([
-    Query(() => AggregatedStocks),
-    WmsOperation({ resource: 'stock', action: 'read' }),
-    __param(0, Args()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [FindStockArgs]),
-    __metadata("design:returntype", Promise)
-], StockQuery.prototype, "aggregatedStocks", null);
-__decorate([
-    Query(() => ChangeLogs),
-    WmsOperation({ resource: 'stock', action: 'read' }),
-    __param(0, Args()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [FindStockArgs]),
-    __metadata("design:returntype", Promise)
-], StockQuery.prototype, "changeLogs", null);
-StockQuery = __decorate([
-    Injectable(),
-    __metadata("design:paramtypes", [StockService])
-], StockQuery);
-
-export { StockQuery };

package/lib/queries/transfer-order.query.js

@@ -1,46 +0,0 @@
-import { __decorate, __param, __metadata } from 'tslib';
-import { Injectable } from '@nestjs/common';
-import { Query, Args, ID } from '@nestjs/graphql';
-import { TransferOrderService } from '@rytass/wms-module-core';
-import { TransferOrders, TransferOrderDto } from '../dto/transfer-order.dto.js';
-import { FindTransferOrderArgs } from '../inputs/find-transfer-order.args.js';
-import '../auth/wms-auth.guard.js';
-import { WmsOperation } from '../auth/wms-operation.decorator.js';
-
-let TransferOrderQuery = class TransferOrderQuery {
-    transferOrderService;
-    constructor(transferOrderService) {
-        this.transferOrderService = transferOrderService;
-    }
-    async transferOrders(args) {
-        const [items, total] = await this.transferOrderService.findMany(args);
-        return { items, total };
-    }
-    async transferOrder(id) {
-        return this.transferOrderService.transferOrderRepository.findOneByOrFail({
-            id,
-        });
-    }
-};
-__decorate([
-    Query(() => TransferOrders),
-    WmsOperation({ resource: 'transfer-order', action: 'read' }),
-    __param(0, Args()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [FindTransferOrderArgs]),
-    __metadata("design:returntype", Promise)
-], TransferOrderQuery.prototype, "transferOrders", null);
-__decorate([
-    Query(() => TransferOrderDto),
-    WmsOperation({ resource: 'transfer-order', action: 'read' }),
-    __param(0, Args('id', { type: () => ID })),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String]),
-    __metadata("design:returntype", Promise)
-], TransferOrderQuery.prototype, "transferOrder", null);
-TransferOrderQuery = __decorate([
-    Injectable(),
-    __metadata("design:paramtypes", [TransferOrderService])
-], TransferOrderQuery);
-
-export { TransferOrderQuery };

package/lib/queries/unit.query.js

@@ -1,30 +0,0 @@
-import { __decorate, __metadata } from 'tslib';
-import { Injectable } from '@nestjs/common';
-import { UnitDto } from '../dto/unit.dto.js';
-import { Query } from '@nestjs/graphql';
-import { UnitService } from '@rytass/wms-module-core';
-import '../auth/wms-auth.guard.js';
-import { WmsOperation } from '../auth/wms-operation.decorator.js';
-
-let UnitQuery = class UnitQuery {
-    unitService;
-    constructor(unitService) {
-        this.unitService = unitService;
-    }
-    units() {
-        return this.unitService.unitRepository.findBy({});
-    }
-};
-__decorate([
-    Query(() => [UnitDto]),
-    WmsOperation({ resource: 'unit', action: 'read' }),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", []),
-    __metadata("design:returntype", Promise)
-], UnitQuery.prototype, "units", null);
-UnitQuery = __decorate([
-    Injectable(),
-    __metadata("design:paramtypes", [UnitService])
-], UnitQuery);
-
-export { UnitQuery };

package/lib/queries/warehouse-map.query.js

@@ -1,32 +0,0 @@
-import { __decorate, __param, __metadata } from 'tslib';
-import { Injectable } from '@nestjs/common';
-import { Query, Args } from '@nestjs/graphql';
-import { MapDataDto } from '../dto/warehouse-map.dto.js';
-import { WarehouseMapDataService } from '@rytass/wms-module-core';
-import '../auth/wms-auth.guard.js';
-import { WmsOperation } from '../auth/wms-operation.decorator.js';
-
-let WarehouseMapDataQuery = class WarehouseMapDataQuery {
-    warehouseMapDataService;
-    constructor(warehouseMapDataService) {
-        this.warehouseMapDataService = warehouseMapDataService;
-    }
-    async mapData(key) {
-        const { mapData } = await this.warehouseMapDataService.warehouseMapDataRepository.findOneByOrFail({ id: key });
-        return mapData;
-    }
-};
-__decorate([
-    Query(() => MapDataDto),
-    WmsOperation({ resource: 'warehouse-map', action: 'read' }),
-    __param(0, Args('key')),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String]),
-    __metadata("design:returntype", Promise)
-], WarehouseMapDataQuery.prototype, "mapData", null);
-WarehouseMapDataQuery = __decorate([
-    Injectable(),
-    __metadata("design:paramtypes", [WarehouseMapDataService])
-], WarehouseMapDataQuery);
-
-export { WarehouseMapDataQuery };

package/lib/registry/operation-registry.js

@@ -1,136 +0,0 @@
-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

@@ -1,119 +0,0 @@
-import { __decorate, __param, __metadata } from 'tslib';
-import { ResolveField, ID, Parent, Context, Resolver } from '@nestjs/graphql';
-import '../dto/loader-type.dto.js';
-import { LoaderDto } from '../dto/loader.dto.js';
-import { MaterialDto } from '../dto/material.dto.js';
-import '../dto/material-unit.dto.js';
-import { AggregatedStockDto } from '../dto/stock.dto.js';
-import '../dto/sale-order.dto.js';
-import '../dto/receive-inventory-order.dto.js';
-import '../dto/receive-inventory-order-item.dto.js';
-import '../dto/ship-inventory-order.dto.js';
-import '../dto/ship-inventory-order-item.dto.js';
-import '../dto/hold-inventory-order.dto.js';
-import '../dto/hold-inventory-order-item.dto.js';
-import '../dto/allocate-inventory-order.dto.js';
-import '../dto/allocate-inventory-order-item.dto.js';
-import '../dto/transfer-order.dto.js';
-import '../dto/transfer-order-item.dto.js';
-import '../dto/transfer-customer-order.dto.js';
-import '../dto/transfer-customer-order-item.dto.js';
-import '../dto/transfer-vendor-order.dto.js';
-import '../dto/transfer-vendor-order-item.dto.js';
-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 '../dto/consumption-order.dto.js';
-import '../dto/consumption-order-item.dto.js';
-import '../dto/order-reference.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';
-
-let AggregatedStockResolver = class AggregatedStockResolver {
-    stockService;
-    entities;
-    constructor(stockService, entities) {
-        this.stockService = stockService;
-        this.entities = entities;
-    }
-    async id(stock) {
-        return this.stockService.generatedAggregateKey(stock);
-    }
-    async 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: BatchGroupEntityClass,
-            __from: { id: groupId },
-        });
-    }
-    async location({ locationId }, { loaders }) {
-        return loaders.batchSingle.load({
-            __entity: this.entities.location,
-            __from: { id: locationId },
-        });
-    }
-    async loader({ loaderId }, { loaders }) {
-        return loaders.batchSingle.load({
-            __entity: LoadersEntityClass,
-            __from: { id: loaderId },
-        });
-    }
-};
-__decorate([
-    ResolveField(() => ID),
-    __param(0, Parent()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [AggregatedStockDto]),
-    __metadata("design:returntype", Promise)
-], AggregatedStockResolver.prototype, "id", null);
-__decorate([
-    ResolveField(() => MaterialDto),
-    __param(0, Parent()),
-    __param(1, Context()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [AggregatedStockDto, Object]),
-    __metadata("design:returntype", Promise)
-], AggregatedStockResolver.prototype, "material", null);
-__decorate([
-    ResolveField(() => BatchDto),
-    __param(0, Parent()),
-    __param(1, Context()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [AggregatedStockDto, Object]),
-    __metadata("design:returntype", Promise)
-], AggregatedStockResolver.prototype, "batch", null);
-__decorate([
-    ResolveField(() => LocationDto),
-    __param(0, Parent()),
-    __param(1, Context()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [AggregatedStockDto, Object]),
-    __metadata("design:returntype", Promise)
-], AggregatedStockResolver.prototype, "location", null);
-__decorate([
-    ResolveField(() => LoaderDto),
-    __param(0, Parent()),
-    __param(1, Context()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [AggregatedStockDto, Object]),
-    __metadata("design:returntype", Promise)
-], AggregatedStockResolver.prototype, "loader", null);
-AggregatedStockResolver = __decorate([
-    Resolver(() => AggregatedStockDto),
-    __metadata("design:paramtypes", [StockService,
-        WmsEntities])
-], AggregatedStockResolver);
-
-export { AggregatedStockResolver };

package/lib/resolvers/allocate-inventory-order.resolver.js

@@ -1,27 +0,0 @@
-import { __decorate, __param, __metadata } from 'tslib';
-import { ResolveField, Parent, Context, Resolver } from '@nestjs/graphql';
-import { AllocateInventoryOrderDto } from '../dto/allocate-inventory-order.dto.js';
-import { AllocateInventoryOrderItemDto } from '../dto/allocate-inventory-order-item.dto.js';
-import { AllocateInventoryOrderEntityClass, AllocateInventoryOrderItemEntityClass } from '@rytass/wms-module-core';
-
-let AllocateInventoryOrderResolver = class AllocateInventoryOrderResolver {
-    items({ id }, { loaders }) {
-        return loaders.batchMany.load({
-            __entity: AllocateInventoryOrderItemEntityClass,
-            __from: { orderId: id },
-        });
-    }
-};
-__decorate([
-    ResolveField(() => [AllocateInventoryOrderItemDto]),
-    __param(0, Parent()),
-    __param(1, Context()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [AllocateInventoryOrderEntityClass, Object]),
-    __metadata("design:returntype", Promise)
-], AllocateInventoryOrderResolver.prototype, "items", null);
-AllocateInventoryOrderResolver = __decorate([
-    Resolver(() => AllocateInventoryOrderDto)
-], AllocateInventoryOrderResolver);
-
-export { AllocateInventoryOrderResolver };

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

@@ -1,99 +0,0 @@
-import { __decorate, __param, __metadata } from 'tslib';
-import { ResolveField, Parent, Context, Resolver } from '@nestjs/graphql';
-import '../dto/loader-type.dto.js';
-import '../dto/loader.dto.js';
-import { MaterialDto } from '../dto/material.dto.js';
-import '../dto/material-unit.dto.js';
-import { ChangeLogDto } from '../dto/stock.dto.js';
-import '../dto/sale-order.dto.js';
-import '../dto/receive-inventory-order.dto.js';
-import '../dto/receive-inventory-order-item.dto.js';
-import '../dto/ship-inventory-order.dto.js';
-import '../dto/ship-inventory-order-item.dto.js';
-import '../dto/hold-inventory-order.dto.js';
-import '../dto/hold-inventory-order-item.dto.js';
-import '../dto/allocate-inventory-order.dto.js';
-import '../dto/allocate-inventory-order-item.dto.js';
-import '../dto/transfer-order.dto.js';
-import '../dto/transfer-order-item.dto.js';
-import '../dto/transfer-customer-order.dto.js';
-import '../dto/transfer-customer-order-item.dto.js';
-import '../dto/transfer-vendor-order.dto.js';
-import '../dto/transfer-vendor-order-item.dto.js';
-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 '../dto/consumption-order.dto.js';
-import '../dto/consumption-order-item.dto.js';
-import '../dto/order-reference.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';
-
-let ChangeLogResolver = class ChangeLogResolver {
-    entities;
-    /**
-     * The configured entities, not the built-in classes: `__entity` decides which
-     * repository the DataLoader opens, so it has to follow whatever the consumer
-     * passed to `WMSBaseModuleOptions`. Loading a built-in class outright filters
-     * on its single-table-inheritance discriminator and resolves nothing for an
-     * override.
-     */
-    constructor(entities) {
-        this.entities = entities;
-    }
-    material({ materialId }, { loaders }) {
-        return loaders.batchSingle.load({
-            __entity: this.entities.material,
-            __from: { id: materialId },
-        });
-    }
-    location({ locationId }, { loaders }) {
-        return loaders.batchSingle.load({
-            __entity: this.entities.location,
-            __from: { id: locationId },
-        });
-    }
-    async batch({ batchId }, { loaders }) {
-        const { groupId } = await loaders.batchSingle.load({
-            __entity: this.entities.batch,
-            __from: { id: batchId },
-        });
-        return loaders.batchSingle.load({
-            __entity: BatchGroupEntityClass,
-            __from: { id: groupId },
-        });
-    }
-};
-__decorate([
-    ResolveField(() => MaterialDto),
-    __param(0, Parent()),
-    __param(1, Context()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [StockEntityClass, Object]),
-    __metadata("design:returntype", Promise)
-], ChangeLogResolver.prototype, "material", null);
-__decorate([
-    ResolveField(() => LocationDto),
-    __param(0, Parent()),
-    __param(1, Context()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [StockEntityClass, Object]),
-    __metadata("design:returntype", Promise)
-], ChangeLogResolver.prototype, "location", null);
-__decorate([
-    ResolveField(() => BatchDto),
-    __param(0, Parent()),
-    __param(1, Context()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [StockEntityClass, Object]),
-    __metadata("design:returntype", Promise)
-], ChangeLogResolver.prototype, "batch", null);
-ChangeLogResolver = __decorate([
-    Resolver(() => ChangeLogDto),
-    __metadata("design:paramtypes", [WmsEntities])
-], ChangeLogResolver);
-
-export { ChangeLogResolver };