@rytass/wms-module-graphql 0.1.0

package/lib/dto/transfer-vendor-order-item.dto.js

@@ -0,0 +1,61 @@
+import { __decorate, __metadata } from 'tslib';
+import { Field, ID, Int, ObjectType } from '@nestjs/graphql';
+import { PaginatedResponse } from './pagination.dto.js';
+
+let TransferVendorOrderItemDto = class TransferVendorOrderItemDto {
+    id;
+    materialId;
+    batchId;
+    locationId;
+    loaderId;
+    vendorId;
+    orderId;
+    unitId;
+    targetTransferredQuantity;
+};
+__decorate([
+    Field(() => ID),
+    __metadata("design:type", String)
+], TransferVendorOrderItemDto.prototype, "id", void 0);
+__decorate([
+    Field(() => ID),
+    __metadata("design:type", String)
+], TransferVendorOrderItemDto.prototype, "materialId", void 0);
+__decorate([
+    Field(() => ID),
+    __metadata("design:type", String)
+], TransferVendorOrderItemDto.prototype, "batchId", void 0);
+__decorate([
+    Field(() => ID, { nullable: true }),
+    __metadata("design:type", Object)
+], TransferVendorOrderItemDto.prototype, "locationId", void 0);
+__decorate([
+    Field(() => ID, { nullable: true }),
+    __metadata("design:type", Object)
+], TransferVendorOrderItemDto.prototype, "loaderId", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], TransferVendorOrderItemDto.prototype, "vendorId", void 0);
+__decorate([
+    Field(() => ID),
+    __metadata("design:type", String)
+], TransferVendorOrderItemDto.prototype, "orderId", void 0);
+__decorate([
+    Field(() => ID, { nullable: true }),
+    __metadata("design:type", Object)
+], TransferVendorOrderItemDto.prototype, "unitId", void 0);
+__decorate([
+    Field(() => Int),
+    __metadata("design:type", Number)
+], TransferVendorOrderItemDto.prototype, "targetTransferredQuantity", void 0);
+TransferVendorOrderItemDto = __decorate([
+    ObjectType()
+], TransferVendorOrderItemDto);
+let TransferVendorOrderItems = class TransferVendorOrderItems extends PaginatedResponse(TransferVendorOrderItemDto) {
+};
+TransferVendorOrderItems = __decorate([
+    ObjectType()
+], TransferVendorOrderItems);
+
+export { TransferVendorOrderItemDto, TransferVendorOrderItems };

package/lib/dto/transfer-vendor-order.dto.d.ts

@@ -0,0 +1,11 @@
+import { TransferVendorOrderItemDto } from './transfer-vendor-order-item.dto';
+export declare class TransferVendorOrderDto {
+    id: string;
+    key: string;
+    createdAt: Date;
+    items: TransferVendorOrderItemDto[];
+}
+declare const TransferVendorOrders_base: new () => import("./pagination.dto").PaginatedType<TransferVendorOrderDto>;
+export declare class TransferVendorOrders extends TransferVendorOrders_base {
+}
+export {};

package/lib/dto/transfer-vendor-order.dto.js

@@ -0,0 +1,37 @@
+import { __decorate, __metadata } from 'tslib';
+import { Field, ID, ObjectType } from '@nestjs/graphql';
+import { TransferVendorOrderItemDto } from './transfer-vendor-order-item.dto.js';
+import { PaginatedResponse } from './pagination.dto.js';
+
+let TransferVendorOrderDto = class TransferVendorOrderDto {
+    id;
+    key;
+    createdAt;
+    items;
+};
+__decorate([
+    Field(() => ID),
+    __metadata("design:type", String)
+], TransferVendorOrderDto.prototype, "id", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], TransferVendorOrderDto.prototype, "key", void 0);
+__decorate([
+    Field(() => Date),
+    __metadata("design:type", Date)
+], TransferVendorOrderDto.prototype, "createdAt", void 0);
+__decorate([
+    Field(() => [TransferVendorOrderItemDto]),
+    __metadata("design:type", Array)
+], TransferVendorOrderDto.prototype, "items", void 0);
+TransferVendorOrderDto = __decorate([
+    ObjectType()
+], TransferVendorOrderDto);
+let TransferVendorOrders = class TransferVendorOrders extends PaginatedResponse(TransferVendorOrderDto) {
+};
+TransferVendorOrders = __decorate([
+    ObjectType()
+], TransferVendorOrders);
+
+export { TransferVendorOrderDto, TransferVendorOrders };

package/lib/dto/unit.dto.d.ts

@@ -0,0 +1,4 @@
+export declare class UnitDto {
+    id: string;
+    key: string;
+}

package/lib/dto/unit.dto.js

@@ -0,0 +1,20 @@
+import { __decorate, __metadata } from 'tslib';
+import { Field, ID, ObjectType } from '@nestjs/graphql';
+
+let UnitDto = class UnitDto {
+    id;
+    key;
+};
+__decorate([
+    Field(() => ID),
+    __metadata("design:type", String)
+], UnitDto.prototype, "id", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], UnitDto.prototype, "key", void 0);
+UnitDto = __decorate([
+    ObjectType()
+], UnitDto);
+
+export { UnitDto };

package/lib/dto/warehouse-map.dto.d.ts

@@ -0,0 +1,39 @@
+export declare enum MapRangeType {
+    RECTANGLE = "RECTANGLE",
+    POLYGON = "POLYGON"
+}
+export declare class MapPolygonRangePointDto {
+    x: number;
+    y: number;
+}
+export declare class MapBackgroundDto {
+    id: string;
+    filename: string;
+    x: number;
+    y: number;
+    height: number;
+    width: number;
+}
+export declare abstract class MapRangeDto {
+    id: string;
+}
+export declare class MapRectangleRangeDto {
+    id: string;
+    type: MapRangeType;
+    color: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export declare class MapPolygonRangeDto {
+    id: string;
+    type: MapRangeType;
+    color: string;
+    points: MapPolygonRangePointDto[];
+}
+export declare class MapDataDto {
+    id: string;
+    backgrounds: MapBackgroundDto[];
+    ranges: MapRangeDto[];
+}

package/lib/dto/warehouse-map.dto.js

@@ -0,0 +1,165 @@
+import { __decorate, __metadata } from 'tslib';
+import { registerEnumType, Field, Float, ObjectType, ID, InterfaceType } from '@nestjs/graphql';
+
+var MapRangeType;
+(function (MapRangeType) {
+    MapRangeType["RECTANGLE"] = "RECTANGLE";
+    MapRangeType["POLYGON"] = "POLYGON";
+})(MapRangeType || (MapRangeType = {}));
+registerEnumType(MapRangeType, {
+    name: 'MapRangeType',
+    description: 'The type of map range',
+});
+let MapPolygonRangePointDto = class MapPolygonRangePointDto {
+    x;
+    y;
+};
+__decorate([
+    Field(() => Float),
+    __metadata("design:type", Number)
+], MapPolygonRangePointDto.prototype, "x", void 0);
+__decorate([
+    Field(() => Float),
+    __metadata("design:type", Number)
+], MapPolygonRangePointDto.prototype, "y", void 0);
+MapPolygonRangePointDto = __decorate([
+    ObjectType()
+], MapPolygonRangePointDto);
+let MapBackgroundDto = class MapBackgroundDto {
+    id;
+    filename;
+    x;
+    y;
+    height;
+    width;
+};
+__decorate([
+    Field(() => ID),
+    __metadata("design:type", String)
+], MapBackgroundDto.prototype, "id", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], MapBackgroundDto.prototype, "filename", void 0);
+__decorate([
+    Field(() => Float),
+    __metadata("design:type", Number)
+], MapBackgroundDto.prototype, "x", void 0);
+__decorate([
+    Field(() => Float),
+    __metadata("design:type", Number)
+], MapBackgroundDto.prototype, "y", void 0);
+__decorate([
+    Field(() => Float),
+    __metadata("design:type", Number)
+], MapBackgroundDto.prototype, "height", void 0);
+__decorate([
+    Field(() => Float),
+    __metadata("design:type", Number)
+], MapBackgroundDto.prototype, "width", void 0);
+MapBackgroundDto = __decorate([
+    ObjectType()
+], MapBackgroundDto);
+let MapRangeDto = class MapRangeDto {
+    id;
+};
+MapRangeDto = __decorate([
+    InterfaceType({
+        resolveType: (value) => {
+            if (value.type === MapRangeType.RECTANGLE) {
+                return MapRectangleRangeDto;
+            }
+            if (value.type === MapRangeType.POLYGON) {
+                return MapPolygonRangeDto;
+            }
+            return null;
+        },
+    })
+], MapRangeDto);
+let MapRectangleRangeDto = class MapRectangleRangeDto {
+    id;
+    type;
+    color;
+    x;
+    y;
+    width;
+    height;
+};
+__decorate([
+    Field(() => ID),
+    __metadata("design:type", String)
+], MapRectangleRangeDto.prototype, "id", void 0);
+__decorate([
+    Field(() => MapRangeType),
+    __metadata("design:type", String)
+], MapRectangleRangeDto.prototype, "type", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], MapRectangleRangeDto.prototype, "color", void 0);
+__decorate([
+    Field(() => Float),
+    __metadata("design:type", Number)
+], MapRectangleRangeDto.prototype, "x", void 0);
+__decorate([
+    Field(() => Float),
+    __metadata("design:type", Number)
+], MapRectangleRangeDto.prototype, "y", void 0);
+__decorate([
+    Field(() => Float),
+    __metadata("design:type", Number)
+], MapRectangleRangeDto.prototype, "width", void 0);
+__decorate([
+    Field(() => Float),
+    __metadata("design:type", Number)
+], MapRectangleRangeDto.prototype, "height", void 0);
+MapRectangleRangeDto = __decorate([
+    ObjectType({ implements: [MapRangeDto] })
+], MapRectangleRangeDto);
+let MapPolygonRangeDto = class MapPolygonRangeDto {
+    id;
+    type;
+    color;
+    points;
+};
+__decorate([
+    Field(() => ID),
+    __metadata("design:type", String)
+], MapPolygonRangeDto.prototype, "id", void 0);
+__decorate([
+    Field(() => MapRangeType),
+    __metadata("design:type", String)
+], MapPolygonRangeDto.prototype, "type", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], MapPolygonRangeDto.prototype, "color", void 0);
+__decorate([
+    Field(() => [MapPolygonRangePointDto]),
+    __metadata("design:type", Array)
+], MapPolygonRangeDto.prototype, "points", void 0);
+MapPolygonRangeDto = __decorate([
+    ObjectType({ implements: [MapRangeDto] })
+], MapPolygonRangeDto);
+let MapDataDto = class MapDataDto {
+    id;
+    backgrounds;
+    ranges;
+};
+__decorate([
+    Field(() => ID),
+    __metadata("design:type", String)
+], MapDataDto.prototype, "id", void 0);
+__decorate([
+    Field(() => [MapBackgroundDto]),
+    __metadata("design:type", Array)
+], MapDataDto.prototype, "backgrounds", void 0);
+__decorate([
+    Field(() => [MapRangeDto]),
+    __metadata("design:type", Array)
+], MapDataDto.prototype, "ranges", void 0);
+MapDataDto = __decorate([
+    ObjectType()
+], MapDataDto);
+
+export { MapBackgroundDto, MapDataDto, MapPolygonRangeDto, MapPolygonRangePointDto, MapRangeDto, MapRangeType, MapRectangleRangeDto };

package/lib/graphql.module.d.ts

@@ -0,0 +1,6 @@
+import { DynamicModule } from '@nestjs/common';
+import { GqlModuleAsyncOptions } from '@nestjs/graphql';
+import type { WmsModuleCoreModuleAsyncOptions } from '@rytass/wms-module-core';
+export declare class WmsModuleGraphqlModule {
+    static forRootAsync(options: WmsModuleCoreModuleAsyncOptions, gqlOptions: GqlModuleAsyncOptions): DynamicModule;
+}

package/lib/graphql.module.js

@@ -0,0 +1,157 @@
+import { __decorate } from 'tslib';
+import { Module } from '@nestjs/common';
+import { GraphQLModule } from '@nestjs/graphql';
+import { WmsModuleCoreModule } from '@rytass/wms-module-core';
+import { LoaderService } from './helpers/loader.service.js';
+import { HelperModule } from './helpers/helper.module.js';
+import './helpers/query-path.js';
+import { LoaderMutation } from './mutations/loader.mutation.js';
+import { LoaderQuery } from './queries/loader.query.js';
+import { MaterialMutation } from './mutations/material.mutation.js';
+import { MaterialQuery } from './queries/material.query.js';
+import { StockQuery } from './queries/stock.query.js';
+import { ReceiveInventoryOrderMutation } from './mutations/receive-inventory-order.mutation.js';
+import { ReceiveInventoryOrderQuery } from './queries/recieve-inventory-order.query.js';
+import { ShipInventoryOrderMutation } from './mutations/ship-inventory-order.mutation.js';
+import { ShipInventoryOrderQuery } from './queries/ship-inventory-order.query.js';
+import { LoaderResolver } from './resolvers/loader.resolver.js';
+import { MaterialResolver } from './resolvers/material.resolver.js';
+import { StockResolver } from './resolvers/stock.resolver.js';
+import { WarehouseMapMutation } from './mutations/warehouse-map.mutation.js';
+import { LocationResolver } from './resolvers/location.resolver.js';
+import { LocationQuery } from './queries/location.query.js';
+import { LocationMutation } from './mutations/location.mutation.js';
+import { LoaderTypeResolver } from './resolvers/loader-type.resolver.js';
+import { UnitQuery } from './queries/unit.query.js';
+import { AggregatedStockResolver } from './resolvers/aggregated-stock.resolver.js';
+import { TransferOrderMutation } from './mutations/transfer-order.mutation.js';
+import { TransferOrderQuery } from './queries/transfer-order.query.js';
+import { TransferOrderResolver, TransferOrderItemResolver } from './resolvers/transfer-order.resolver.js';
+import { HoldInventoryOrderMutation } from './mutations/hold-inventory-order.mutation.js';
+import { HoldInventoryOrderQuery } from './queries/hold-inventory-order.query.js';
+import { HoldInventoryOrderResolver } from './resolvers/hold-inventory-order.resolver.js';
+import { BatchQuery } from './queries/batch.query.js';
+import { ChangeLogResolver } from './resolvers/change-log.resolver.js';
+import { ReceiveInventoryOrderResolver, ReceiveInventoryOrderItemResolver } from './resolvers/receive-inventory-order.resolver.js';
+import { AllocateInventoryOrderQuery } from './queries/allocate-inventory-order.query.js';
+import { AllocateInventoryOrderResolver } from './resolvers/allocate-inventory-order.resolver.js';
+import { AllocateInventoryOrderMutation } from './mutations/allocate-inventory-order.mutation.js';
+import { ShipInventoryOrderResolver, ShipInventoryOrderItemResolver, ShipInventoryOrderReferenceResolver } from './resolvers/ship-inventory-order.resolver.js';
+import { SaleOrderQuery } from './queries/sale-order.query.js';
+import { SplitBatchMutation } from './mutations/split-batch.mutation.js';
+import { MergeBatchMutation } from './mutations/merge-batch.mutation.js';
+import { ReclassifyInventoryOrderMutation } from './mutations/reclassify-inventory-order.mutation.js';
+import { TransferCustomerOrderMutation } from './mutations/transfer-customer-order.mutation.js';
+import { TransferCustomerOrderResolver } from './resolvers/transfer-customer-order.resolver.js';
+import { TransferVendorOrderMutation } from './mutations/transfer-vendor-order.mutation.js';
+import { TransferVendorOrderResolver } from './resolvers/transfer-vendor-order.resolver.js';
+import { SplitBatchResolver } from './resolvers/split-batch.resolver.js';
+import { MergeBatchOrderResolver } from './resolvers/merge-batch.resolver.js';
+import { ScrapeMutation } from './mutations/scrape-order.mutation.js';
+import { QualityInspectionOrderMutation } from './mutations/quality-inspection-order.mutation.js';
+import { WarehouseMapDataQuery } from './queries/warehouse-map.query.js';
+import { MapRangeUnionResolver } from './resolvers/warehouse-map.resolver.js';
+
+var WmsModuleGraphqlModule_1;
+const exportDependencies = [
+    UnitQuery,
+    LoaderMutation,
+    LoaderQuery,
+    LoaderResolver,
+    LoaderTypeResolver,
+    MaterialMutation,
+    MaterialQuery,
+    MaterialResolver,
+    BatchQuery,
+    StockQuery,
+    StockResolver,
+    ChangeLogResolver,
+    AggregatedStockResolver,
+    ReceiveInventoryOrderMutation,
+    ReceiveInventoryOrderQuery,
+    ReceiveInventoryOrderResolver,
+    ReceiveInventoryOrderItemResolver,
+    ShipInventoryOrderMutation,
+    ShipInventoryOrderQuery,
+    ShipInventoryOrderResolver,
+    ShipInventoryOrderItemResolver,
+    ShipInventoryOrderReferenceResolver,
+    TransferOrderMutation,
+    TransferOrderQuery,
+    TransferOrderResolver,
+    HoldInventoryOrderMutation,
+    HoldInventoryOrderQuery,
+    HoldInventoryOrderResolver,
+    WarehouseMapMutation,
+    LocationMutation,
+    LocationQuery,
+    LocationResolver,
+    TransferOrderMutation,
+    TransferOrderResolver,
+    TransferOrderItemResolver,
+    AllocateInventoryOrderQuery,
+    AllocateInventoryOrderResolver,
+    AllocateInventoryOrderMutation,
+    TransferCustomerOrderMutation,
+    TransferCustomerOrderResolver,
+    TransferVendorOrderMutation,
+    TransferVendorOrderResolver,
+    SaleOrderQuery,
+    SplitBatchMutation,
+    SplitBatchResolver,
+    MergeBatchMutation,
+    MergeBatchOrderResolver,
+    ReclassifyInventoryOrderMutation,
+    ScrapeMutation,
+    QualityInspectionOrderMutation,
+    WarehouseMapDataQuery,
+    MapRangeUnionResolver,
+];
+let WmsModuleGraphqlModule = WmsModuleGraphqlModule_1 = class WmsModuleGraphqlModule {
+    static forRootAsync(options, gqlOptions) {
+        const coreModule = WmsModuleCoreModule.forRootAsync(options);
+        return {
+            module: WmsModuleGraphqlModule_1,
+            imports: [
+                coreModule,
+                HelperModule,
+                GraphQLModule.forRootAsync({
+                    ...gqlOptions,
+                    imports: [HelperModule, ...(gqlOptions.imports || [])],
+                    inject: [LoaderService, ...(gqlOptions.inject || [])],
+                    useFactory: async (loaderService, ...args) => {
+                        const loaders = {
+                            batchSingle: loaderService.batchEntity(),
+                            batchMany: loaderService.batchEntities(),
+                            batchManyWithPagination: loaderService.batchEntitiesWithPagination(),
+                        };
+                        const originalFactory = gqlOptions.useFactory
+                            ? await gqlOptions.useFactory(...args)
+                            : {};
+                        return {
+                            ...originalFactory,
+                            context: async (contextArg) => {
+                                const context = typeof gqlOptions.useFactory === 'function'
+                                    ? {
+                                        loaders,
+                                        ...(typeof contextArg === 'object' ? contextArg : {}),
+                                    }
+                                    : { loaders, ...contextArg };
+                                return context;
+                            },
+                        };
+                    },
+                }),
+            ],
+            providers: exportDependencies,
+            exports: [GraphQLModule, coreModule],
+        };
+    }
+};
+WmsModuleGraphqlModule = WmsModuleGraphqlModule_1 = __decorate([
+    Module({
+        providers: exportDependencies,
+    })
+], WmsModuleGraphqlModule);
+
+export { WmsModuleGraphqlModule };

package/lib/helpers/dataloader.type.d.ts

@@ -0,0 +1,12 @@
+import DataLoader from 'dataloader';
+import { LoaderOptions, LoaderOptionsWithPagination } from './loader.service';
+export interface LoaderType<T> {
+    loaders: {
+        batchMany: DataLoader<LoaderOptions<T>, T[]>;
+        batchSingle: DataLoader<LoaderOptions<T>, T>;
+        batchManyWithPagination: DataLoader<LoaderOptionsWithPagination<T>, {
+            items: T[];
+            total: number;
+        }>;
+    };
+}

package/lib/helpers/helper.module.d.ts

@@ -0,0 +1,2 @@
+export declare class HelperModule {
+}

package/lib/helpers/helper.module.js

@@ -0,0 +1,15 @@
+import { __decorate } from 'tslib';
+import { Global, Module } from '@nestjs/common';
+import { LoaderService } from './loader.service.js';
+
+let HelperModule = class HelperModule {
+};
+HelperModule = __decorate([
+    Global(),
+    Module({
+        providers: [LoaderService],
+        exports: [LoaderService],
+    })
+], HelperModule);
+
+export { HelperModule };

package/lib/helpers/index.d.ts

@@ -0,0 +1,4 @@
+export * from './dataloader.type';
+export * from './loader.service';
+export * from './helper.module';
+export * from './query-path';

package/lib/helpers/loader.service.d.ts

@@ -0,0 +1,56 @@
+import { DataSource, FindOptionsWhere, ObjectLiteral, SelectQueryBuilder } from 'typeorm';
+import DataLoader from 'dataloader';
+export interface LoaderOptions<K> {
+    __entity: ObjectLiteral;
+    __from: FindOptionsWhere<K>;
+    __conditions?: (qb: SelectQueryBuilder<ObjectLiteral>) => SelectQueryBuilder<ObjectLiteral>;
+    __seed?: string;
+    __pagination?: {
+        offset: number;
+        limit: number;
+    };
+}
+export interface LoaderOptionsWithPagination<K> extends LoaderOptions<K> {
+    __pagination: {
+        offset: number;
+        limit: number;
+    };
+}
+export declare class LoaderService {
+    private dataSource;
+    private readonly cache;
+    constructor(dataSource: DataSource);
+    /**
+     * create hash from `__entity` in loader option, and return option with `__hash` set with hash value.
+     * @param LoaderOptions
+     * @returns LoaderOptions
+     */
+    private useHash;
+    /**
+     * generate index by queried data primary keys, which is defined in loader option `__from`
+     * @param object
+     * @param LoaderOptions
+     * @returns Map<string, data>
+     */
+    private useIndex;
+    /**
+     * query data by collecting primary keys from options with same `__entity`
+     * @param LoaderOptions[]
+     * @returns object[]
+     */
+    core<T>(options: LoaderOptions<T>[]): Promise<ObjectLiteral[]>;
+    /**
+     * batch single entity to load function calls.
+     * @returns object
+     */
+    batchEntity<T>(): DataLoader<LoaderOptions<T>, T, LoaderOptions<T>>;
+    /**
+     * batch many entities to load function calls.
+     * @returns object[]
+     */
+    batchEntities<T>(): DataLoader<LoaderOptions<T>, T[], LoaderOptions<T>>;
+    batchEntitiesWithPagination<T>(): DataLoader<LoaderOptionsWithPagination<T>, {
+        items: T[];
+        total: number;
+    }, LoaderOptionsWithPagination<T>>;
+}