@rytass/wms-module-graphql 0.1.0

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

@@ -0,0 +1,81 @@
+import { __decorate, __param, __metadata } from 'tslib';
+import { Injectable } from '@nestjs/common';
+import { Mutation, Args } from '@nestjs/graphql';
+import { HoldInventoryOrderService, StockService } from '@rytass/wms-module-core';
+import { HoldInventoryOrderDto } from '../dto/hold-inventory-order.dto.js';
+import { CreateHoldInventoryOrderArgs, UpdateHoldInventoryOrderArgs } from '../inputs/create-hold-inventory-order.args.js';
+import { ReleaseOrderArgs } from '../inputs/release-order.args.js';
+
+let HoldInventoryOrderMutation = class HoldInventoryOrderMutation {
+    holdInventoryOrderService;
+    stockService;
+    constructor(holdInventoryOrderService, stockService) {
+        this.holdInventoryOrderService = holdInventoryOrderService;
+        this.stockService = stockService;
+    }
+    async createHoldInventoryOrder(args) {
+        return this.holdInventoryOrderService.createHoldInventoryOrder({
+            ...args,
+            items: args.items.map(({ aggregatedKey, ...item }) => {
+                const keys = this.stockService.destructAggregateKey(aggregatedKey);
+                return {
+                    ...item,
+                    ...keys,
+                };
+            }),
+        });
+    }
+    async updateHoldInventoryOrder(args) {
+        return this.holdInventoryOrderService.updateHoldInventoryOrder({
+            ...args,
+            items: args?.items?.map(({ aggregatedKey, ...item }) => {
+                const keys = aggregatedKey
+                    ? this.stockService.destructAggregateKey(aggregatedKey)
+                    : {};
+                return {
+                    ...item,
+                    ...keys,
+                };
+            }),
+        });
+    }
+    async release(args) {
+        return this.holdInventoryOrderService
+            .release(args.map(({ aggregatedKey, ...item }) => {
+            const keys = this.stockService.destructAggregateKey(aggregatedKey);
+            return {
+                ...item,
+                ...keys,
+            };
+        }))
+            .then(() => true);
+    }
+};
+__decorate([
+    Mutation(() => HoldInventoryOrderDto),
+    __param(0, Args()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [CreateHoldInventoryOrderArgs]),
+    __metadata("design:returntype", Promise)
+], HoldInventoryOrderMutation.prototype, "createHoldInventoryOrder", null);
+__decorate([
+    Mutation(() => HoldInventoryOrderDto),
+    __param(0, Args()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [UpdateHoldInventoryOrderArgs]),
+    __metadata("design:returntype", Promise)
+], HoldInventoryOrderMutation.prototype, "updateHoldInventoryOrder", null);
+__decorate([
+    Mutation(() => Boolean),
+    __param(0, Args('items', { type: () => [ReleaseOrderArgs] })),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array]),
+    __metadata("design:returntype", Promise)
+], HoldInventoryOrderMutation.prototype, "release", null);
+HoldInventoryOrderMutation = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [HoldInventoryOrderService,
+        StockService])
+], HoldInventoryOrderMutation);
+
+export { HoldInventoryOrderMutation };

package/lib/mutations/loader.mutation.d.ts

@@ -0,0 +1,13 @@
+import { LoaderService } from '@rytass/wms-module-core';
+import { LoaderDto, LoaderTypeDto } from '../dto';
+import { CreateLoaderTypeArgs, UpdateLoaderTypeArgs } from '../inputs/create-loader-type.args';
+import { CreateLoaderArgs, CreateLoadersArgs, UpdateLoaderArgs } from '../inputs/create-loader.args';
+export declare class LoaderMutation {
+    private readonly loaderService;
+    constructor(loaderService: LoaderService);
+    createLoader(args: CreateLoaderArgs): Promise<LoaderDto[]>;
+    createBatchLoader(args: CreateLoadersArgs[]): Promise<LoaderDto[]>;
+    updateLoader(args: UpdateLoaderArgs): Promise<LoaderDto>;
+    createLoaderType(args: CreateLoaderTypeArgs): Promise<LoaderTypeDto>;
+    updateLoaderType(args: UpdateLoaderTypeArgs): Promise<LoaderTypeDto>;
+}

package/lib/mutations/loader.mutation.js

@@ -0,0 +1,105 @@
+import { __decorate, __param, __metadata } from 'tslib';
+import { Injectable } from '@nestjs/common';
+import { LoaderService } from '@rytass/wms-module-core';
+import { LoaderTypeDto } from '../dto/loader-type.dto.js';
+import { LoaderDto } from '../dto/loader.dto.js';
+import '../dto/material.dto.js';
+import '../dto/material-unit.dto.js';
+import '../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 { 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';
+import { In } from 'typeorm';
+
+let LoaderMutation = class LoaderMutation {
+    loaderService;
+    constructor(loaderService) {
+        this.loaderService = loaderService;
+    }
+    async createLoader(args) {
+        return this.loaderService.createLoader(args);
+    }
+    async createBatchLoader(args) {
+        const types = await this.loaderService.loaderTypeRepository.find({
+            where: {
+                key: In(args.map((arg) => arg.typeKey)),
+            },
+        });
+        const typeMap = new Map(types.map((type) => [type.key, type.id]));
+        return this.loaderService.createBatchLoaders({
+            options: args.map((arg) => ({
+                ...arg,
+                typeId: typeMap.get(arg.typeKey),
+            })),
+        });
+    }
+    async updateLoader(args) {
+        return this.loaderService.updateLoader(args);
+    }
+    createLoaderType(args) {
+        return this.loaderService.createLoaderType(args);
+    }
+    async updateLoaderType(args) {
+        return this.loaderService.updateLoaderType(args);
+    }
+};
+__decorate([
+    Mutation(() => [LoaderDto]),
+    __param(0, Args()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [CreateLoaderArgs]),
+    __metadata("design:returntype", Promise)
+], LoaderMutation.prototype, "createLoader", null);
+__decorate([
+    Mutation(() => [LoaderDto]),
+    __param(0, Args('items', { type: () => [CreateLoadersArgs] })),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array]),
+    __metadata("design:returntype", Promise)
+], LoaderMutation.prototype, "createBatchLoader", null);
+__decorate([
+    Mutation(() => LoaderDto),
+    __param(0, Args()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [UpdateLoaderArgs]),
+    __metadata("design:returntype", Promise)
+], LoaderMutation.prototype, "updateLoader", null);
+__decorate([
+    Mutation(() => LoaderTypeDto),
+    __param(0, Args()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [CreateLoaderTypeArgs]),
+    __metadata("design:returntype", Promise)
+], LoaderMutation.prototype, "createLoaderType", null);
+__decorate([
+    Mutation(() => LoaderTypeDto),
+    __param(0, Args()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [UpdateLoaderTypeArgs]),
+    __metadata("design:returntype", Promise)
+], LoaderMutation.prototype, "updateLoaderType", null);
+LoaderMutation = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [LoaderService])
+], LoaderMutation);
+
+export { LoaderMutation };

package/lib/mutations/location.mutation.d.ts

@@ -0,0 +1,8 @@
+import { LocationService } from '@rytass/wms-module-core';
+import { CreateLocationArgs, UpdateLocationArgs } from '../inputs/create-location.args';
+export declare class LocationMutation {
+    private readonly locationService;
+    constructor(locationService: LocationService);
+    createLocation(args: CreateLocationArgs): Promise<import("@rytass/wms-module-core").LocationEntityClass>;
+    updateLocation(args: UpdateLocationArgs): Promise<import("@rytass/wms-module-core").LocationEntityClass>;
+}

package/lib/mutations/location.mutation.js

@@ -0,0 +1,39 @@
+import { __decorate, __param, __metadata } from 'tslib';
+import { Injectable } from '@nestjs/common';
+import { Mutation, Args } from '@nestjs/graphql';
+import { LocationService } from '@rytass/wms-module-core';
+import { LocationDto } from '../dto/location.dto.js';
+import { CreateLocationArgs, UpdateLocationArgs } from '../inputs/create-location.args.js';
+
+let LocationMutation = class LocationMutation {
+    locationService;
+    constructor(locationService) {
+        this.locationService = locationService;
+    }
+    async createLocation(args) {
+        return this.locationService.createLocation(args);
+    }
+    async updateLocation(args) {
+        return this.locationService.updateLocation(args);
+    }
+};
+__decorate([
+    Mutation(() => LocationDto),
+    __param(0, Args()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [CreateLocationArgs]),
+    __metadata("design:returntype", Promise)
+], LocationMutation.prototype, "createLocation", null);
+__decorate([
+    Mutation(() => LocationDto),
+    __param(0, Args()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [UpdateLocationArgs]),
+    __metadata("design:returntype", Promise)
+], LocationMutation.prototype, "updateLocation", null);
+LocationMutation = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [LocationService])
+], LocationMutation);
+
+export { LocationMutation };

package/lib/mutations/material.mutation.d.ts

@@ -0,0 +1,9 @@
+import { MaterialDto } from '../dto';
+import { CreateMaterialArgs, UpdateMaterialArgs } from '../inputs/create-material.args';
+import { MaterialService } from '@rytass/wms-module-core';
+export declare class MaterialMutation {
+    private readonly materialService;
+    constructor(materialService: MaterialService);
+    createMaterial(args: CreateMaterialArgs): Promise<MaterialDto>;
+    updateMaterial(args: UpdateMaterialArgs): Promise<MaterialDto>;
+}

package/lib/mutations/material.mutation.js

@@ -0,0 +1,62 @@
+import { __decorate, __param, __metadata } from 'tslib';
+import { Injectable } from '@nestjs/common';
+import { Mutation, Args } 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 '../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 { CreateMaterialArgs, UpdateMaterialArgs } from '../inputs/create-material.args.js';
+import { MaterialService } from '@rytass/wms-module-core';
+
+let MaterialMutation = class MaterialMutation {
+    materialService;
+    constructor(materialService) {
+        this.materialService = materialService;
+    }
+    async createMaterial(args) {
+        return this.materialService.createMaterial(args);
+    }
+    async updateMaterial(args) {
+        return this.materialService.updateMaterial(args);
+    }
+};
+__decorate([
+    Mutation(() => MaterialDto),
+    __param(0, Args()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [CreateMaterialArgs]),
+    __metadata("design:returntype", Promise)
+], MaterialMutation.prototype, "createMaterial", null);
+__decorate([
+    Mutation(() => MaterialDto),
+    __param(0, Args()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [UpdateMaterialArgs]),
+    __metadata("design:returntype", Promise)
+], MaterialMutation.prototype, "updateMaterial", null);
+MaterialMutation = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [MaterialService])
+], MaterialMutation);
+
+export { MaterialMutation };

package/lib/mutations/merge-batch.mutation.d.ts

@@ -0,0 +1,9 @@
+import { MergeBatchOrderService, StockService } from '@rytass/wms-module-core';
+import { MergeBatchArgs } from '../inputs/merge-batch.args';
+import { MergeBatchOrderDto } from '../dto/merge-batch-order.dto';
+export declare class MergeBatchMutation {
+    private readonly stockService;
+    private readonly mergeBatchOrderService;
+    constructor(stockService: StockService, mergeBatchOrderService: MergeBatchOrderService);
+    mergeBatch(args: MergeBatchArgs): Promise<MergeBatchOrderDto>;
+}

package/lib/mutations/merge-batch.mutation.js

@@ -0,0 +1,44 @@
+import { __decorate, __param, __metadata } from 'tslib';
+import { Injectable } from '@nestjs/common';
+import { Mutation, Args, Resolver } from '@nestjs/graphql';
+import { StockService, MergeBatchOrderService } from '@rytass/wms-module-core';
+import { MergeBatchArgs } from '../inputs/merge-batch.args.js';
+import { MergeBatchOrderDto } from '../dto/merge-batch-order.dto.js';
+
+let MergeBatchMutation = class MergeBatchMutation {
+    stockService;
+    mergeBatchOrderService;
+    constructor(stockService, mergeBatchOrderService) {
+        this.stockService = stockService;
+        this.mergeBatchOrderService = mergeBatchOrderService;
+    }
+    async mergeBatch(args) {
+        return this.mergeBatchOrderService.merge({
+            ...args,
+            items: args.items.map((item) => {
+                const { batchId, locationId, loaderId } = this.stockService.destructAggregateKey(item.aggregatedKey);
+                return {
+                    ...item,
+                    batchId,
+                    locationId,
+                    loaderId,
+                };
+            }),
+        });
+    }
+};
+__decorate([
+    Mutation(() => MergeBatchOrderDto),
+    __param(0, Args()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [MergeBatchArgs]),
+    __metadata("design:returntype", Promise)
+], MergeBatchMutation.prototype, "mergeBatch", null);
+MergeBatchMutation = __decorate([
+    Injectable(),
+    Resolver(),
+    __metadata("design:paramtypes", [StockService,
+        MergeBatchOrderService])
+], MergeBatchMutation);
+
+export { MergeBatchMutation };

package/lib/mutations/quality-inspection-order.mutation.d.ts

@@ -0,0 +1,9 @@
+import { QualityInspectionOrderService, StockService } from '@rytass/wms-module-core';
+import { QualityInspectionOrderDto } from '../dto/quality-inspection-order.dto';
+import { CreateQualityInspectionOrderArgs } from '../inputs/create-quality-inspection-order.args';
+export declare class QualityInspectionOrderMutation {
+    private readonly qualityInspectionOrderService;
+    private readonly stockService;
+    constructor(qualityInspectionOrderService: QualityInspectionOrderService, stockService: StockService);
+    inspectMaterials(args: CreateQualityInspectionOrderArgs): Promise<QualityInspectionOrderDto>;
+}

package/lib/mutations/quality-inspection-order.mutation.js

@@ -0,0 +1,44 @@
+import { __decorate, __param, __metadata } from 'tslib';
+import { Injectable } from '@nestjs/common';
+import { Mutation, Args } from '@nestjs/graphql';
+import { QualityInspectionOrderService, StockService } from '@rytass/wms-module-core';
+import { QualityInspectionOrderDto } from '../dto/quality-inspection-order.dto.js';
+import { CreateQualityInspectionOrderArgs } from '../inputs/create-quality-inspection-order.args.js';
+
+let QualityInspectionOrderMutation = class QualityInspectionOrderMutation {
+    qualityInspectionOrderService;
+    stockService;
+    constructor(qualityInspectionOrderService, stockService) {
+        this.qualityInspectionOrderService = qualityInspectionOrderService;
+        this.stockService = stockService;
+    }
+    async inspectMaterials(args) {
+        return this.qualityInspectionOrderService.inspect({
+            options: {
+                key: args.key,
+                note: args.note,
+                items: args.items.map(({ aggregateKey, ...item }) => {
+                    const keys = this.stockService.destructAggregateKey(aggregateKey);
+                    return {
+                        ...item,
+                        ...keys,
+                    };
+                }),
+            },
+        });
+    }
+};
+__decorate([
+    Mutation(() => QualityInspectionOrderDto),
+    __param(0, Args()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [CreateQualityInspectionOrderArgs]),
+    __metadata("design:returntype", Promise)
+], QualityInspectionOrderMutation.prototype, "inspectMaterials", null);
+QualityInspectionOrderMutation = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [QualityInspectionOrderService,
+        StockService])
+], QualityInspectionOrderMutation);
+
+export { QualityInspectionOrderMutation };

package/lib/mutations/receive-inventory-order.mutation.d.ts

@@ -0,0 +1,13 @@
+import { ReceiveInventoryOrderService } from '@rytass/wms-module-core';
+import { ReceiveInventoryOrderDto } from '../dto';
+import { CreateReceiveInventoryOrderArgs, UpdateReceiveInventoryOrderArgs } from '../inputs/create-receive-inventory-order.args';
+import { DataSource } from 'typeorm';
+import { ReceiveOrderArgs } from '../inputs/receive-order.args';
+export declare class ReceiveInventoryOrderMutation {
+    private readonly dataSource;
+    private readonly receiveInventoryOrderService;
+    constructor(dataSource: DataSource, receiveInventoryOrderService: ReceiveInventoryOrderService);
+    createReceiveInventoryOrder(args: CreateReceiveInventoryOrderArgs): Promise<ReceiveInventoryOrderDto>;
+    updateReceiveInventoryOrder(args: UpdateReceiveInventoryOrderArgs): Promise<ReceiveInventoryOrderDto>;
+    receive(items: ReceiveOrderArgs[]): Promise<boolean>;
+}

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

@@ -0,0 +1,92 @@
+import { __decorate, __param, __metadata } from 'tslib';
+import { Injectable } from '@nestjs/common';
+import { Mutation, Args } from '@nestjs/graphql';
+import { ReceiveInventoryOrderService } from '@rytass/wms-module-core';
+import '../dto/loader-type.dto.js';
+import '../dto/loader.dto.js';
+import '../dto/material.dto.js';
+import '../dto/material-unit.dto.js';
+import '../dto/stock.dto.js';
+import '../dto/sale-order.dto.js';
+import { ReceiveInventoryOrderDto } from '../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 { CreateReceiveInventoryOrderArgs, UpdateReceiveInventoryOrderArgs } from '../inputs/create-receive-inventory-order.args.js';
+import { DataSource } from 'typeorm';
+import { ReceiveOrderArgs } from '../inputs/receive-order.args.js';
+
+let ReceiveInventoryOrderMutation = class ReceiveInventoryOrderMutation {
+    dataSource;
+    receiveInventoryOrderService;
+    constructor(dataSource, receiveInventoryOrderService) {
+        this.dataSource = dataSource;
+        this.receiveInventoryOrderService = receiveInventoryOrderService;
+    }
+    async createReceiveInventoryOrder(args) {
+        const { id } = await this.dataSource.transaction(async (manager) => this.receiveInventoryOrderService.createReceiveInventoryOrder({
+            ...args,
+            manager,
+        }));
+        return this.receiveInventoryOrderService
+            .selectQueryBuilder('orders')
+            .where('orders.id = :id', { id })
+            .getRawOne();
+    }
+    async updateReceiveInventoryOrder(args) {
+        const { id } = await this.dataSource.transaction(async (manager) => this.receiveInventoryOrderService.updateReceiveInventoryOrder({
+            ...args,
+            manager,
+        }));
+        return this.receiveInventoryOrderService
+            .selectQueryBuilder('orders')
+            .where('orders.id = :id', { id })
+            .getRawOne();
+    }
+    async receive(items) {
+        await this.receiveInventoryOrderService.receive(items);
+        return true;
+    }
+};
+__decorate([
+    Mutation(() => ReceiveInventoryOrderDto),
+    __param(0, Args()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [CreateReceiveInventoryOrderArgs]),
+    __metadata("design:returntype", Promise)
+], ReceiveInventoryOrderMutation.prototype, "createReceiveInventoryOrder", null);
+__decorate([
+    Mutation(() => ReceiveInventoryOrderDto),
+    __param(0, Args()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [UpdateReceiveInventoryOrderArgs]),
+    __metadata("design:returntype", Promise)
+], ReceiveInventoryOrderMutation.prototype, "updateReceiveInventoryOrder", null);
+__decorate([
+    Mutation(() => Boolean),
+    __param(0, Args('items', { type: () => [ReceiveOrderArgs] })),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array]),
+    __metadata("design:returntype", Promise)
+], ReceiveInventoryOrderMutation.prototype, "receive", null);
+ReceiveInventoryOrderMutation = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [DataSource,
+        ReceiveInventoryOrderService])
+], ReceiveInventoryOrderMutation);
+
+export { ReceiveInventoryOrderMutation };

package/lib/mutations/reclassify-inventory-order.mutation.d.ts

@@ -0,0 +1,9 @@
+import { ReclassifyInventoryOrderService, StockService } from '@rytass/wms-module-core';
+import { ReclassifyInventoryOrderArgs } from '../inputs/reclassify-inventory-order.args';
+import { ReclassifyInventoryOrderDto } from '../dto/reclassify-inventory-order.dto';
+export declare class ReclassifyInventoryOrderMutation {
+    private readonly stockService;
+    private readonly reclassifyInventoryOrderService;
+    constructor(stockService: StockService, reclassifyInventoryOrderService: ReclassifyInventoryOrderService);
+    reclassifyInventoryOrder(args: ReclassifyInventoryOrderArgs): Promise<ReclassifyInventoryOrderDto>;
+}

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

@@ -0,0 +1,45 @@
+import { __decorate, __param, __metadata } from 'tslib';
+import { Injectable } from '@nestjs/common';
+import { Mutation, Args, Resolver } from '@nestjs/graphql';
+import { StockService, ReclassifyInventoryOrderService } from '@rytass/wms-module-core';
+import { ReclassifyInventoryOrderArgs } from '../inputs/reclassify-inventory-order.args.js';
+import { ReclassifyInventoryOrderDto } from '../dto/reclassify-inventory-order.dto.js';
+
+let ReclassifyInventoryOrderMutation = class ReclassifyInventoryOrderMutation {
+    stockService;
+    reclassifyInventoryOrderService;
+    constructor(stockService, reclassifyInventoryOrderService) {
+        this.stockService = stockService;
+        this.reclassifyInventoryOrderService = reclassifyInventoryOrderService;
+    }
+    async reclassifyInventoryOrder(args) {
+        return this.reclassifyInventoryOrderService.reclassify({
+            materialKey: args.materialKey,
+            items: args.items.map((item) => {
+                const { materialId, batchId, locationId, loaderId } = this.stockService.destructAggregateKey(item.aggregatedKey);
+                return {
+                    ...item,
+                    materialId,
+                    batchId,
+                    locationId,
+                    loaderId,
+                };
+            }),
+        });
+    }
+};
+__decorate([
+    Mutation(() => ReclassifyInventoryOrderDto),
+    __param(0, Args()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ReclassifyInventoryOrderArgs]),
+    __metadata("design:returntype", Promise)
+], ReclassifyInventoryOrderMutation.prototype, "reclassifyInventoryOrder", null);
+ReclassifyInventoryOrderMutation = __decorate([
+    Injectable(),
+    Resolver(),
+    __metadata("design:paramtypes", [StockService,
+        ReclassifyInventoryOrderService])
+], ReclassifyInventoryOrderMutation);
+
+export { ReclassifyInventoryOrderMutation };

package/lib/mutations/scrape-order.mutation.d.ts

@@ -0,0 +1,9 @@
+import { ScrapeService, StockService } from '@rytass/wms-module-core';
+import { ScrapeOrderDto } from '../dto/scrape-order.dto';
+import { ScrapeOrderArgs } from '../inputs/scrape-order.args';
+export declare class ScrapeMutation {
+    private readonly scrapeService;
+    private readonly stockService;
+    constructor(scrapeService: ScrapeService, stockService: StockService);
+    scrapeMaterials(args: ScrapeOrderArgs): Promise<ScrapeOrderDto>;
+}

package/lib/mutations/scrape-order.mutation.js

@@ -0,0 +1,38 @@
+import { __decorate, __param, __metadata } from 'tslib';
+import { Injectable } from '@nestjs/common';
+import { Mutation, Args } from '@nestjs/graphql';
+import { ScrapeService, StockService } from '@rytass/wms-module-core';
+import { ScrapeOrderDto } from '../dto/scrape-order.dto.js';
+import { ScrapeOrderArgs } from '../inputs/scrape-order.args.js';
+
+let ScrapeMutation = class ScrapeMutation {
+    scrapeService;
+    stockService;
+    constructor(scrapeService, stockService) {
+        this.scrapeService = scrapeService;
+        this.stockService = stockService;
+    }
+    async scrapeMaterials(args) {
+        return this.scrapeService.scrape(args.items.map(({ aggregateKey, ...item }) => {
+            const keys = this.stockService.destructAggregateKey(aggregateKey);
+            return {
+                ...item,
+                ...keys,
+            };
+        }));
+    }
+};
+__decorate([
+    Mutation(() => ScrapeOrderDto),
+    __param(0, Args()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ScrapeOrderArgs]),
+    __metadata("design:returntype", Promise)
+], ScrapeMutation.prototype, "scrapeMaterials", null);
+ScrapeMutation = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [ScrapeService,
+        StockService])
+], ScrapeMutation);
+
+export { ScrapeMutation };

package/lib/mutations/ship-inventory-order.mutation.d.ts

@@ -0,0 +1,14 @@
+import { ShipInventoryOrderService, StockService } from '@rytass/wms-module-core';
+import { ShipInventoryOrderDto } from '../dto';
+import { CreateShipInventoryOrderArgs, UpdateShipInventoryOrderArgs } from '../inputs/create-ship-inventory-order.args';
+import { ShipOrderArgs } from '../inputs/ship-order.args';
+import { CancelShipOrderArgs } from '../inputs/cancel-ship-order.args';
+export declare class ShipInventoryOrderMutation {
+    private readonly shipInventoryOrderService;
+    private readonly stockService;
+    constructor(shipInventoryOrderService: ShipInventoryOrderService, stockService: StockService);
+    createShipInventoryOrder(args: CreateShipInventoryOrderArgs): Promise<ShipInventoryOrderDto>;
+    updateShipInventoryOrder(args: UpdateShipInventoryOrderArgs): Promise<ShipInventoryOrderDto>;
+    ship(items: ShipOrderArgs[]): Promise<boolean>;
+    cancelShip(items: CancelShipOrderArgs[]): Promise<boolean>;
+}