@rytass/wms-module-graphql 0.1.0

package/lib/resolvers/stock.resolver.js

@@ -0,0 +1,83 @@
+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 { StockDto } 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 { StockEntityClass, MaterialEntityClass, LocationEntityClass, BatchEntityClass, BatchGroupEntityClass } from '@rytass/wms-module-core';
+import { LocationDto } from '../dto/location.dto.js';
+import { BatchDto } from '../dto/batch.dto.js';
+
+let StockResolver = class StockResolver {
+    material({ materialId }, { loaders }) {
+        return loaders.batchSingle.load({
+            __entity: MaterialEntityClass,
+            __from: { id: materialId },
+        });
+    }
+    location({ locationId }, { loaders }) {
+        return loaders.batchSingle.load({
+            __entity: LocationEntityClass,
+            __from: { id: locationId },
+        });
+    }
+    async batch({ batchId }, { loaders }) {
+        const { groupId } = await loaders.batchSingle.load({
+            __entity: BatchEntityClass,
+            __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)
+], StockResolver.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)
+], StockResolver.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)
+], StockResolver.prototype, "batch", null);
+StockResolver = __decorate([
+    Resolver(() => StockDto)
+], StockResolver);
+
+export { StockResolver };

package/lib/resolvers/transfer-customer-order.resolver.d.ts

@@ -0,0 +1,6 @@
+import { TransferCustomerOrderItemDto } from '../dto/transfer-customer-order-item.dto';
+import { TransferCustomerOrderEntityClass, TransferCustomerOrderItemEntityClass } from '@rytass/wms-module-core';
+import { type LoaderType } from '../helpers';
+export declare class TransferCustomerOrderResolver {
+    items({ id }: TransferCustomerOrderEntityClass, { loaders }: LoaderType<TransferCustomerOrderItemEntityClass>): Promise<TransferCustomerOrderItemDto[]>;
+}

package/lib/resolvers/transfer-customer-order.resolver.js

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

package/lib/resolvers/transfer-order.resolver.d.ts

@@ -0,0 +1,21 @@
+import { TransferOrderDto } from '../dto/transfer-order.dto';
+import { TransferOrderItemDto } from '../dto/transfer-order-item.dto';
+import { type LoaderType } from '../helpers';
+import { BatchEntityClass, LoadersEntityClass, LocationEntityClass, MaterialEntityClass, TransferOrderChangeEntityClass, TransferOrderItemEntityClass } from '@rytass/wms-module-core';
+import { LoaderDto, MaterialDto } from '../dto';
+import { BatchDto } from '../dto/batch.dto';
+import { LocationDto } from '../dto/location.dto';
+export declare class TransferOrderResolver {
+    items({ id }: TransferOrderDto, { loaders }: LoaderType<TransferOrderItemEntityClass>): Promise<TransferOrderItemDto[]>;
+    targetLocation({ id }: TransferOrderDto, { loaders }: LoaderType<TransferOrderItemEntityClass>, locationLoader: LoaderType<LocationEntityClass>): Promise<LocationDto | null>;
+    targetLoader({ id }: TransferOrderDto, { loaders }: LoaderType<TransferOrderItemEntityClass>, loaderLoader: LoaderType<LoadersEntityClass>): Promise<LoaderDto | null>;
+}
+export declare class TransferOrderItemResolver {
+    material({ materialId }: TransferOrderItemEntityClass, { loaders }: LoaderType<MaterialEntityClass>): Promise<MaterialDto>;
+    batch({ batchId }: TransferOrderItemEntityClass, { loaders }: LoaderType<BatchEntityClass>): Promise<BatchDto | null>;
+    location({ locationId }: TransferOrderItemEntityClass, { loaders }: LoaderType<LocationEntityClass>): Promise<LocationDto | null>;
+    loader({ loaderId }: TransferOrderItemEntityClass, { loaders }: LoaderType<LoadersEntityClass>): Promise<LoaderDto | null>;
+    saleId({ batchId }: TransferOrderItemEntityClass, { loaders }: LoaderType<BatchEntityClass>): Promise<string | null>;
+    saleSerialId({ batchId }: TransferOrderItemEntityClass, { loaders }: LoaderType<BatchEntityClass>): Promise<string | null>;
+    transferredQuantity({ id }: TransferOrderItemEntityClass, { loaders }: LoaderType<TransferOrderChangeEntityClass>): Promise<number>;
+}

package/lib/resolvers/transfer-order.resolver.js

@@ -0,0 +1,218 @@
+import { __decorate, __param, __metadata } from 'tslib';
+import { ResolveField, Parent, Context, Resolver, ID, Int } from '@nestjs/graphql';
+import { TransferOrderDto } from '../dto/transfer-order.dto.js';
+import { TransferOrderItemDto } from '../dto/transfer-order-item.dto.js';
+import { TransferOrderItemEntityClass, LocationEntityClass, LoadersEntityClass, MaterialEntityClass, BatchEntityClass, BatchGroupEntityClass, TransferOrderChangeEntityClass } from '@rytass/wms-module-core';
+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 '../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-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 { BatchDto } from '../dto/batch.dto.js';
+import { LocationDto } from '../dto/location.dto.js';
+
+let TransferOrderResolver = class TransferOrderResolver {
+    items({ id }, { loaders }) {
+        return loaders.batchMany.load({
+            __entity: TransferOrderItemEntityClass,
+            __from: { orderId: id },
+        });
+    }
+    async targetLocation({ id }, { loaders }, locationLoader) {
+        const [item] = await loaders.batchMany.load({
+            __entity: TransferOrderItemEntityClass,
+            __from: { orderId: id },
+        });
+        if (!item?.targetLocationId)
+            return null;
+        return locationLoader.loaders.batchSingle.load({
+            __entity: LocationEntityClass,
+            __from: { id: item.targetLocationId },
+        });
+    }
+    async targetLoader({ id }, { loaders }, loaderLoader) {
+        const [item] = await loaders.batchMany.load({
+            __entity: TransferOrderItemEntityClass,
+            __from: { orderId: id },
+        });
+        if (!item?.targetLoaderId)
+            return null;
+        return loaderLoader.loaders.batchSingle.load({
+            __entity: LoadersEntityClass,
+            __from: { id: item.targetLoaderId },
+        });
+    }
+};
+__decorate([
+    ResolveField(() => [TransferOrderItemDto]),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [TransferOrderDto, Object]),
+    __metadata("design:returntype", Promise)
+], TransferOrderResolver.prototype, "items", null);
+__decorate([
+    ResolveField(() => LocationDto, { nullable: true }),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __param(2, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [TransferOrderDto, Object, Object]),
+    __metadata("design:returntype", Promise)
+], TransferOrderResolver.prototype, "targetLocation", null);
+__decorate([
+    ResolveField(() => LoaderDto, { nullable: true }),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __param(2, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [TransferOrderDto, Object, Object]),
+    __metadata("design:returntype", Promise)
+], TransferOrderResolver.prototype, "targetLoader", null);
+TransferOrderResolver = __decorate([
+    Resolver(() => TransferOrderDto)
+], TransferOrderResolver);
+let TransferOrderItemResolver = class TransferOrderItemResolver {
+    material({ materialId }, { loaders }) {
+        return loaders.batchSingle.load({
+            __entity: MaterialEntityClass,
+            __from: { id: materialId },
+        });
+    }
+    async batch({ batchId }, { loaders }) {
+        if (!batchId)
+            return null;
+        const { groupId } = await loaders.batchSingle.load({
+            __entity: BatchEntityClass,
+            __from: { id: batchId },
+        });
+        return loaders.batchSingle.load({
+            __entity: BatchGroupEntityClass,
+            __from: { id: groupId },
+        });
+    }
+    async location({ locationId }, { loaders }) {
+        if (!locationId)
+            return null;
+        return loaders.batchSingle.load({
+            __entity: LocationEntityClass,
+            __from: { id: locationId },
+        });
+    }
+    async loader({ loaderId }, { loaders }) {
+        if (!loaderId)
+            return null;
+        return loaders.batchSingle.load({
+            __entity: LoadersEntityClass,
+            __from: { id: loaderId },
+        });
+    }
+    async saleId({ batchId }, { loaders }) {
+        if (!batchId)
+            return null;
+        return loaders.batchSingle
+            .load({
+            __entity: BatchEntityClass,
+            __from: { id: batchId },
+        })
+            .then((batch) => batch.saleId);
+    }
+    async saleSerialId({ batchId }, { loaders }) {
+        if (!batchId)
+            return null;
+        return loaders.batchSingle
+            .load({
+            __entity: BatchEntityClass,
+            __from: { id: batchId },
+        })
+            .then((batch) => batch.saleSerialId);
+    }
+    async transferredQuantity({ id }, { loaders }) {
+        const changes = await loaders.batchMany.load({
+            __entity: TransferOrderChangeEntityClass,
+            __from: { itemId: id },
+        });
+        return changes.reduce((acc, { quantityChanged }) => {
+            const qty = Number(quantityChanged);
+            return qty < 0 ? acc + Math.abs(qty) : acc;
+        }, 0);
+    }
+};
+__decorate([
+    ResolveField(() => MaterialDto),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [TransferOrderItemEntityClass, Object]),
+    __metadata("design:returntype", Promise)
+], TransferOrderItemResolver.prototype, "material", null);
+__decorate([
+    ResolveField(() => BatchDto, { nullable: true }),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [TransferOrderItemEntityClass, Object]),
+    __metadata("design:returntype", Promise)
+], TransferOrderItemResolver.prototype, "batch", null);
+__decorate([
+    ResolveField(() => LocationDto, { nullable: true }),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [TransferOrderItemEntityClass, Object]),
+    __metadata("design:returntype", Promise)
+], TransferOrderItemResolver.prototype, "location", null);
+__decorate([
+    ResolveField(() => LoaderDto, { nullable: true }),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [TransferOrderItemEntityClass, Object]),
+    __metadata("design:returntype", Promise)
+], TransferOrderItemResolver.prototype, "loader", null);
+__decorate([
+    ResolveField(() => ID, { nullable: true }),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [TransferOrderItemEntityClass, Object]),
+    __metadata("design:returntype", Promise)
+], TransferOrderItemResolver.prototype, "saleId", null);
+__decorate([
+    ResolveField(() => ID, { nullable: true }),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [TransferOrderItemEntityClass, Object]),
+    __metadata("design:returntype", Promise)
+], TransferOrderItemResolver.prototype, "saleSerialId", null);
+__decorate([
+    ResolveField(() => Int),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [TransferOrderItemEntityClass, Object]),
+    __metadata("design:returntype", Promise)
+], TransferOrderItemResolver.prototype, "transferredQuantity", null);
+TransferOrderItemResolver = __decorate([
+    Resolver(() => TransferOrderItemDto)
+], TransferOrderItemResolver);
+
+export { TransferOrderItemResolver, TransferOrderResolver };

package/lib/resolvers/transfer-vendor-order.resolver.d.ts

@@ -0,0 +1,6 @@
+import { TransferVendorOrderItemDto } from '../dto/transfer-vendor-order-item.dto';
+import { TransferVendorOrderEntityClass, TransferVendorOrderItemEntityClass } from '@rytass/wms-module-core';
+import { type LoaderType } from '../helpers';
+export declare class TransferVendorOrderResolver {
+    items({ id }: TransferVendorOrderEntityClass, { loaders }: LoaderType<TransferVendorOrderItemEntityClass>): Promise<TransferVendorOrderItemDto[]>;
+}

package/lib/resolvers/transfer-vendor-order.resolver.js

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

package/lib/resolvers/warehouse-map.resolver.d.ts

@@ -0,0 +1,6 @@
+import { type LoaderType } from '../helpers';
+import { LocationEntityClass } from '@rytass/wms-module-core';
+import { MapRangeDto } from '../dto/warehouse-map.dto';
+export declare class MapRangeUnionResolver {
+    location({ id }: MapRangeDto, { loaders }: LoaderType<LocationEntityClass>): Promise<LocationEntityClass> | null;
+}

package/lib/resolvers/warehouse-map.resolver.js

@@ -0,0 +1,29 @@
+import { __decorate, __param, __metadata } from 'tslib';
+import { ResolveField, Parent, Context, Resolver } from '@nestjs/graphql';
+import { LocationDto } from '../dto/location.dto.js';
+import { LocationEntityClass } from '@rytass/wms-module-core';
+import { MapRangeDto } from '../dto/warehouse-map.dto.js';
+
+let MapRangeUnionResolver = class MapRangeUnionResolver {
+    location({ id }, { loaders }) {
+        if (!id)
+            return null;
+        return loaders.batchSingle.load({
+            __entity: LocationEntityClass,
+            __from: { key: id },
+        });
+    }
+};
+__decorate([
+    ResolveField(() => LocationDto, { nullable: true }),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [MapRangeDto, Object]),
+    __metadata("design:returntype", void 0)
+], MapRangeUnionResolver.prototype, "location", null);
+MapRangeUnionResolver = __decorate([
+    Resolver(() => MapRangeDto)
+], MapRangeUnionResolver);
+
+export { MapRangeUnionResolver };

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@rytass/wms-module-graphql",
+  "version": "0.1.0",
+  "description": "Rytass WMS Module — GraphQL schema, resolvers and DTOs for warehouse management",
+  "keywords": [
+    "rytass",
+    "wms",
+    "warehouse",
+    "nestjs",
+    "graphql"
+  ],
+  "author": "Chia Yu Pai <fantasyatelier@gmail.com>",
+  "homepage": "https://github.com/Rytass/WMS-Module#readme",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Rytass/WMS-Module.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Rytass/WMS-Module/issues"
+  },
+  "main": "./index.cjs.js",
+  "module": "./index.js",
+  "typings": "./index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "require": "./index.cjs.js",
+      "import": "./index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "**/*.js",
+    "**/*.d.ts",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "dataloader": "^2.2.3"
+  },
+  "peerDependencies": {
+    "@nestjs/apollo": "^13.0.0",
+    "@nestjs/common": "^11.0.0",
+    "@nestjs/graphql": "^13.0.0",
+    "@rytass/wms-module-core": "^0.1.0",
+    "graphql": "^16.0.0",
+    "reflect-metadata": "^0.1.13 || ^0.2.0",
+    "rxjs": "^7.8.0"
+  }
+}