@rytass/wms-module-graphql 0.1.0

package/lib/helpers/loader.service.js

@@ -0,0 +1,168 @@
+import { __decorate, __metadata } from 'tslib';
+import { Injectable } from '@nestjs/common';
+import { createHash } from 'crypto';
+import _ from 'lodash';
+import { LRUCache } from 'lru-cache';
+import { DataSource, In } from 'typeorm';
+import DataLoader from 'dataloader';
+
+let LoaderService = class LoaderService {
+    dataSource;
+    cache;
+    constructor(dataSource) {
+        this.dataSource = dataSource;
+        this.cache = new LRUCache({
+            max: 10000,
+            ttlAutopurge: true,
+            ttl: 500,
+        });
+    }
+    /**
+     * create hash from `__entity` in loader option, and return option with `__hash` set with hash value.
+     * @param LoaderOptions
+     * @returns LoaderOptions
+     */
+    useHash(options) {
+        const algorithm = createHash('sha1');
+        algorithm.update(options.__entity.toString());
+        algorithm.update(_(Object.keys(options.__from)).sort().join(''));
+        if (options.__seed)
+            algorithm.update(options.__seed);
+        if (options.__conditions)
+            algorithm.update(options.__conditions.toString());
+        return { ...options, __hash: algorithm.digest('hex') };
+    }
+    /**
+     * generate index by queried data primary keys, which is defined in loader option `__from`
+     * @param object
+     * @param LoaderOptions
+     * @returns Map<string, data>
+     */
+    useIndex(data, { __hash, __from }) {
+        const fields = _(Object.keys(__from)).sort();
+        return `${__hash}_${fields.map((field) => data[field]).join('_')}`;
+    }
+    /**
+     * query data by collecting primary keys from options with same `__entity`
+     * @param LoaderOptions[]
+     * @returns object[]
+     */
+    async core(options) {
+        const [{ __entity, __from, __conditions }] = options;
+        const repo = this.dataSource.getRepository(__entity);
+        let qb = repo.createQueryBuilder('entity');
+        const primaryKeys = Object.keys(__from);
+        if (primaryKeys.length > 1)
+            qb.setFindOptions({ where: options.map(({ __from }) => __from) });
+        else {
+            const [primaryKey] = primaryKeys;
+            qb.setFindOptions({
+                where: {
+                    [primaryKey]: In(options.map(({ __from }) => __from[primaryKey])),
+                },
+            });
+        }
+        if (__conditions)
+            qb = __conditions(qb);
+        return qb.getMany();
+    }
+    /**
+     * batch single entity to load function calls.
+     * @returns object
+     */
+    batchEntity() {
+        return new DataLoader(async (inputs) => {
+            const options = inputs.map((input) => this.useHash(input));
+            const dataMap = new Map();
+            const processMap = _(options)
+                .groupBy((x) => x.__hash)
+                .value();
+            await Promise.all(Object.keys(processMap).map(async (entityHash) => {
+                const options = processMap[entityHash];
+                const [option] = options;
+                const entities = await this.core(options);
+                entities.map((entity) => dataMap.set(this.useIndex(entity, option), entity));
+            }));
+            return options.map((option) => dataMap.get(this.useIndex(option.__from, option)));
+        }, {
+            batchScheduleFn: (callback) => setTimeout(callback, 50),
+            cacheKeyFn: (option) => this.useIndex(option.__from, this.useHash(option)),
+            cacheMap: this.cache,
+        });
+    }
+    /**
+     * batch many entities to load function calls.
+     * @returns object[]
+     */
+    batchEntities() {
+        return new DataLoader(async (inputs) => {
+            const options = inputs.map((input) => this.useHash(input));
+            const dataMap = new Map();
+            const processMap = _(options)
+                .groupBy((x) => x.__hash)
+                .value();
+            await Promise.all(Object.keys(processMap).map(async (entityHash) => {
+                const options = processMap[entityHash];
+                const [option] = options;
+                const entities = await this.core(options);
+                entities.map((entity) => {
+                    const index = this.useIndex(entity, option);
+                    const entities = dataMap.get(index) ?? [];
+                    entities.push(entity);
+                    dataMap.set(index, entities);
+                });
+            }));
+            return options.map((option) => {
+                const result = dataMap.get(this.useIndex(option.__from, option)) ?? [];
+                return option.__pagination
+                    ? result.slice(option.__pagination.offset, option.__pagination.offset + option.__pagination.limit)
+                    : result;
+            });
+        }, {
+            batchScheduleFn: (callback) => setTimeout(callback, 100),
+            cacheKeyFn: (option) => this.useIndex(option.__from, this.useHash(option)),
+            cacheMap: this.cache,
+        });
+    }
+    batchEntitiesWithPagination() {
+        return new DataLoader(async (inputs) => {
+            const options = inputs.map((input) => this.useHash(input));
+            const dataMap = new Map();
+            const processMap = _(options)
+                .groupBy((x) => x.__hash)
+                .value();
+            await Promise.all(Object.keys(processMap).map(async (entityHash) => {
+                const options = processMap[entityHash];
+                const [option] = options;
+                const entities = await this.core(options);
+                entities.map((entity) => {
+                    const index = this.useIndex(entity, option);
+                    const entities = dataMap.get(index) ?? [];
+                    entities.push(entity);
+                    dataMap.set(index, entities);
+                });
+            }));
+            return options.map((option) => {
+                const result = dataMap.get(this.useIndex(option.__from, option));
+                if (!result)
+                    return { items: [], total: 0 };
+                return {
+                    items: option.__pagination
+                        ? result.slice(option.__pagination.offset, option.__pagination.offset + option.__pagination.limit)
+                        : result,
+                    total: result.length,
+                };
+            });
+        }, {
+            batchScheduleFn: (callback) => setTimeout(callback, 100),
+            cacheKeyFn: (option) => this.useIndex(option.__from, this.useHash(option)),
+            cacheMap: this.cache,
+        });
+    }
+};
+LoaderService = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [DataSource])
+], LoaderService);
+
+export { LoaderService };

package/lib/helpers/query-path.d.ts

@@ -0,0 +1 @@
+export declare const QueryPath: (...dataOrPipes: unknown[]) => ParameterDecorator;

package/lib/helpers/query-path.js

@@ -0,0 +1,19 @@
+import { createParamDecorator } from '@nestjs/common';
+import { GqlExecutionContext } from '@nestjs/graphql';
+import _ from 'lodash';
+
+createParamDecorator((data, context) => {
+    if (context.getType().toString() === 'graphql') {
+        const ctx = GqlExecutionContext.create(context).getInfo();
+        const extractPath = ({ prev, key }, paths) => {
+            if (key && _.isString(key))
+                paths.unshift(key);
+            if (prev)
+                return extractPath(prev, paths);
+            return paths;
+        };
+        const paths = extractPath(ctx.path, []);
+        return paths.join('/');
+    }
+    return null;
+});

package/lib/inputs/cancel-ship-order.args.d.ts

@@ -0,0 +1,4 @@
+export declare class CancelShipOrderArgs {
+    itemId: string;
+    quantity?: number;
+}

package/lib/inputs/cancel-ship-order.args.js

@@ -0,0 +1,20 @@
+import { __decorate, __metadata } from 'tslib';
+import { Field, ID, Int, InputType } from '@nestjs/graphql';
+
+let CancelShipOrderArgs = class CancelShipOrderArgs {
+    itemId;
+    quantity;
+};
+__decorate([
+    Field(() => ID),
+    __metadata("design:type", String)
+], CancelShipOrderArgs.prototype, "itemId", void 0);
+__decorate([
+    Field(() => Int, { nullable: true }),
+    __metadata("design:type", Number)
+], CancelShipOrderArgs.prototype, "quantity", void 0);
+CancelShipOrderArgs = __decorate([
+    InputType()
+], CancelShipOrderArgs);
+
+export { CancelShipOrderArgs };

package/lib/inputs/cancel-transfer-order.args.d.ts

@@ -0,0 +1,4 @@
+export declare class CancelTransferOrderArgs {
+    itemId: string;
+    quantity?: number;
+}

package/lib/inputs/cancel-transfer-order.args.js

@@ -0,0 +1,23 @@
+import { __decorate, __metadata } from 'tslib';
+import { Field, ID, Int, InputType } from '@nestjs/graphql';
+
+let CancelTransferOrderArgs = class CancelTransferOrderArgs {
+    itemId;
+    quantity;
+};
+__decorate([
+    Field(() => ID, { description: 'The ID of transfer order item' }),
+    __metadata("design:type", String)
+], CancelTransferOrderArgs.prototype, "itemId", void 0);
+__decorate([
+    Field(() => Int, {
+        nullable: true,
+        description: 'The quantity to cancel. If not provided, cancels all remaining cancellable quantity.',
+    }),
+    __metadata("design:type", Number)
+], CancelTransferOrderArgs.prototype, "quantity", void 0);
+CancelTransferOrderArgs = __decorate([
+    InputType()
+], CancelTransferOrderArgs);
+
+export { CancelTransferOrderArgs };

package/lib/inputs/create-allocate-inventory-order-item.args.d.ts

@@ -0,0 +1,13 @@
+export declare class CreateAllocateInventoryOrderItemArgs {
+    aggregatedKey: string;
+    unitId?: string;
+    targetAllocatedQuantity: number;
+    saleId: string;
+    saleSerialId: string;
+}
+declare const UpdateAllocateInventoryOrderItemArgs_base: import("@nestjs/common").Type<Partial<CreateAllocateInventoryOrderItemArgs>>;
+export declare class UpdateAllocateInventoryOrderItemArgs extends UpdateAllocateInventoryOrderItemArgs_base {
+    id?: string;
+    removedAt?: Date;
+}
+export {};

package/lib/inputs/create-allocate-inventory-order-item.args.js

@@ -0,0 +1,50 @@
+import { __decorate, __metadata } from 'tslib';
+import { Field, ID, InputType, PartialType } from '@nestjs/graphql';
+
+let CreateAllocateInventoryOrderItemArgs = class CreateAllocateInventoryOrderItemArgs {
+    aggregatedKey;
+    unitId;
+    targetAllocatedQuantity;
+    saleId;
+    saleSerialId;
+};
+__decorate([
+    Field(() => ID),
+    __metadata("design:type", String)
+], CreateAllocateInventoryOrderItemArgs.prototype, "aggregatedKey", void 0);
+__decorate([
+    Field(() => ID, { nullable: true }),
+    __metadata("design:type", String)
+], CreateAllocateInventoryOrderItemArgs.prototype, "unitId", void 0);
+__decorate([
+    Field(() => Number),
+    __metadata("design:type", Number)
+], CreateAllocateInventoryOrderItemArgs.prototype, "targetAllocatedQuantity", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], CreateAllocateInventoryOrderItemArgs.prototype, "saleId", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], CreateAllocateInventoryOrderItemArgs.prototype, "saleSerialId", void 0);
+CreateAllocateInventoryOrderItemArgs = __decorate([
+    InputType()
+], CreateAllocateInventoryOrderItemArgs);
+let UpdateAllocateInventoryOrderItemArgs = class UpdateAllocateInventoryOrderItemArgs extends PartialType(CreateAllocateInventoryOrderItemArgs) {
+    id;
+    removedAt;
+};
+__decorate([
+    Field(() => ID, { nullable: true }),
+    __metadata("design:type", String)
+], UpdateAllocateInventoryOrderItemArgs.prototype, "id", void 0);
+__decorate([
+    Field(() => Date, { nullable: true }),
+    __metadata("design:type", Date)
+], UpdateAllocateInventoryOrderItemArgs.prototype, "removedAt", void 0);
+UpdateAllocateInventoryOrderItemArgs = __decorate([
+    InputType()
+], UpdateAllocateInventoryOrderItemArgs);
+
+export { CreateAllocateInventoryOrderItemArgs, UpdateAllocateInventoryOrderItemArgs };

package/lib/inputs/create-allocate-inventory-order.args.d.ts

@@ -0,0 +1,11 @@
+import { CreateAllocateInventoryOrderItemArgs, UpdateAllocateInventoryOrderItemArgs } from './create-allocate-inventory-order-item.args';
+export declare class CreateAllocateInventoryOrderArgs {
+    items: CreateAllocateInventoryOrderItemArgs[];
+}
+declare const UpdateAllocateInventoryOrderArgs_base: import("@nestjs/common").Type<Partial<Omit<CreateAllocateInventoryOrderArgs, "items">>>;
+export declare class UpdateAllocateInventoryOrderArgs extends UpdateAllocateInventoryOrderArgs_base {
+    id: string;
+    removedAt?: Date;
+    items?: UpdateAllocateInventoryOrderItemArgs[];
+}
+export {};

package/lib/inputs/create-allocate-inventory-order.args.js

@@ -0,0 +1,36 @@
+import { __decorate, __metadata } from 'tslib';
+import { Field, ArgsType, PartialType, OmitType } from '@nestjs/graphql';
+import { CreateAllocateInventoryOrderItemArgs, UpdateAllocateInventoryOrderItemArgs } from './create-allocate-inventory-order-item.args.js';
+
+let CreateAllocateInventoryOrderArgs = class CreateAllocateInventoryOrderArgs {
+    items;
+};
+__decorate([
+    Field(() => [CreateAllocateInventoryOrderItemArgs]),
+    __metadata("design:type", Array)
+], CreateAllocateInventoryOrderArgs.prototype, "items", void 0);
+CreateAllocateInventoryOrderArgs = __decorate([
+    ArgsType()
+], CreateAllocateInventoryOrderArgs);
+let UpdateAllocateInventoryOrderArgs = class UpdateAllocateInventoryOrderArgs extends PartialType(OmitType(CreateAllocateInventoryOrderArgs, ['items'])) {
+    id;
+    removedAt;
+    items;
+};
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], UpdateAllocateInventoryOrderArgs.prototype, "id", void 0);
+__decorate([
+    Field(() => Date, { nullable: true }),
+    __metadata("design:type", Date)
+], UpdateAllocateInventoryOrderArgs.prototype, "removedAt", void 0);
+__decorate([
+    Field(() => [UpdateAllocateInventoryOrderItemArgs], { nullable: true }),
+    __metadata("design:type", Array)
+], UpdateAllocateInventoryOrderArgs.prototype, "items", void 0);
+UpdateAllocateInventoryOrderArgs = __decorate([
+    ArgsType()
+], UpdateAllocateInventoryOrderArgs);
+
+export { CreateAllocateInventoryOrderArgs, UpdateAllocateInventoryOrderArgs };

package/lib/inputs/create-hold-inventory-order-item.args.d.ts

@@ -0,0 +1,11 @@
+export declare class CreateHoldInventoryOrderItemArgs {
+    aggregatedKey: string;
+    unitId?: string;
+    targetHeldQuantity: number;
+}
+declare const UpdateHoldInventoryOrderItemArgs_base: import("@nestjs/common").Type<Partial<CreateHoldInventoryOrderItemArgs>>;
+export declare class UpdateHoldInventoryOrderItemArgs extends UpdateHoldInventoryOrderItemArgs_base {
+    id?: string;
+    removedAt?: Date;
+}
+export {};

package/lib/inputs/create-hold-inventory-order-item.args.js

@@ -0,0 +1,40 @@
+import { __decorate, __metadata } from 'tslib';
+import { Field, ID, InputType, PartialType } from '@nestjs/graphql';
+
+let CreateHoldInventoryOrderItemArgs = class CreateHoldInventoryOrderItemArgs {
+    aggregatedKey;
+    unitId;
+    targetHeldQuantity;
+};
+__decorate([
+    Field(() => ID),
+    __metadata("design:type", String)
+], CreateHoldInventoryOrderItemArgs.prototype, "aggregatedKey", void 0);
+__decorate([
+    Field(() => ID, { nullable: true }),
+    __metadata("design:type", String)
+], CreateHoldInventoryOrderItemArgs.prototype, "unitId", void 0);
+__decorate([
+    Field(() => Number),
+    __metadata("design:type", Number)
+], CreateHoldInventoryOrderItemArgs.prototype, "targetHeldQuantity", void 0);
+CreateHoldInventoryOrderItemArgs = __decorate([
+    InputType()
+], CreateHoldInventoryOrderItemArgs);
+let UpdateHoldInventoryOrderItemArgs = class UpdateHoldInventoryOrderItemArgs extends PartialType(CreateHoldInventoryOrderItemArgs) {
+    id;
+    removedAt;
+};
+__decorate([
+    Field(() => ID, { nullable: true }),
+    __metadata("design:type", String)
+], UpdateHoldInventoryOrderItemArgs.prototype, "id", void 0);
+__decorate([
+    Field(() => Date, { nullable: true }),
+    __metadata("design:type", Date)
+], UpdateHoldInventoryOrderItemArgs.prototype, "removedAt", void 0);
+UpdateHoldInventoryOrderItemArgs = __decorate([
+    InputType()
+], UpdateHoldInventoryOrderItemArgs);
+
+export { CreateHoldInventoryOrderItemArgs, UpdateHoldInventoryOrderItemArgs };

package/lib/inputs/create-hold-inventory-order.args.d.ts

@@ -0,0 +1,12 @@
+import { CreateHoldInventoryOrderItemArgs, UpdateHoldInventoryOrderItemArgs } from './create-hold-inventory-order-item.args';
+export declare class CreateHoldInventoryOrderArgs {
+    createdBy?: string;
+    items: CreateHoldInventoryOrderItemArgs[];
+}
+declare const UpdateHoldInventoryOrderArgs_base: import("@nestjs/common").Type<Partial<Omit<CreateHoldInventoryOrderArgs, "items">>>;
+export declare class UpdateHoldInventoryOrderArgs extends UpdateHoldInventoryOrderArgs_base {
+    id: string;
+    removedAt?: Date;
+    items?: UpdateHoldInventoryOrderItemArgs[];
+}
+export {};

package/lib/inputs/create-hold-inventory-order.args.js

@@ -0,0 +1,41 @@
+import { __decorate, __metadata } from 'tslib';
+import { Field, ArgsType, PartialType, OmitType } from '@nestjs/graphql';
+import { CreateHoldInventoryOrderItemArgs, UpdateHoldInventoryOrderItemArgs } from './create-hold-inventory-order-item.args.js';
+
+let CreateHoldInventoryOrderArgs = class CreateHoldInventoryOrderArgs {
+    createdBy;
+    items;
+};
+__decorate([
+    Field(() => String, { nullable: true }),
+    __metadata("design:type", String)
+], CreateHoldInventoryOrderArgs.prototype, "createdBy", void 0);
+__decorate([
+    Field(() => [CreateHoldInventoryOrderItemArgs]),
+    __metadata("design:type", Array)
+], CreateHoldInventoryOrderArgs.prototype, "items", void 0);
+CreateHoldInventoryOrderArgs = __decorate([
+    ArgsType()
+], CreateHoldInventoryOrderArgs);
+let UpdateHoldInventoryOrderArgs = class UpdateHoldInventoryOrderArgs extends PartialType(OmitType(CreateHoldInventoryOrderArgs, ['items'])) {
+    id;
+    removedAt;
+    items;
+};
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], UpdateHoldInventoryOrderArgs.prototype, "id", void 0);
+__decorate([
+    Field(() => Date, { nullable: true }),
+    __metadata("design:type", Date)
+], UpdateHoldInventoryOrderArgs.prototype, "removedAt", void 0);
+__decorate([
+    Field(() => [UpdateHoldInventoryOrderItemArgs], { nullable: true }),
+    __metadata("design:type", Array)
+], UpdateHoldInventoryOrderArgs.prototype, "items", void 0);
+UpdateHoldInventoryOrderArgs = __decorate([
+    ArgsType()
+], UpdateHoldInventoryOrderArgs);
+
+export { CreateHoldInventoryOrderArgs, UpdateHoldInventoryOrderArgs };

package/lib/inputs/create-loader-type.args.d.ts

@@ -0,0 +1,10 @@
+export declare class CreateLoaderTypeArgs {
+    description: string;
+    key: string;
+}
+declare const UpdateLoaderTypeArgs_base: import("@nestjs/common").Type<Partial<Omit<CreateLoaderTypeArgs, "key">>>;
+export declare class UpdateLoaderTypeArgs extends UpdateLoaderTypeArgs_base {
+    id: string;
+    isActive?: boolean;
+}
+export {};

package/lib/inputs/create-loader-type.args.js

@@ -0,0 +1,35 @@
+import { __decorate, __metadata } from 'tslib';
+import { Field, ArgsType, PartialType, OmitType, ID } from '@nestjs/graphql';
+
+let CreateLoaderTypeArgs = class CreateLoaderTypeArgs {
+    description;
+    key;
+};
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], CreateLoaderTypeArgs.prototype, "description", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], CreateLoaderTypeArgs.prototype, "key", void 0);
+CreateLoaderTypeArgs = __decorate([
+    ArgsType()
+], CreateLoaderTypeArgs);
+let UpdateLoaderTypeArgs = class UpdateLoaderTypeArgs extends PartialType(OmitType(CreateLoaderTypeArgs, ['key'])) {
+    id;
+    isActive;
+};
+__decorate([
+    Field(() => ID),
+    __metadata("design:type", String)
+], UpdateLoaderTypeArgs.prototype, "id", void 0);
+__decorate([
+    Field(() => Boolean, { nullable: true }),
+    __metadata("design:type", Boolean)
+], UpdateLoaderTypeArgs.prototype, "isActive", void 0);
+UpdateLoaderTypeArgs = __decorate([
+    ArgsType()
+], UpdateLoaderTypeArgs);
+
+export { CreateLoaderTypeArgs, UpdateLoaderTypeArgs };

package/lib/inputs/create-loader.args.d.ts

@@ -0,0 +1,30 @@
+export declare class CreateLoaderArgs {
+    typeId: string;
+    locationId: string;
+    quantity: number;
+    length?: number;
+    width?: number;
+    height?: number;
+    sizeUnit?: string;
+    volume?: number;
+    volumeUnit?: string;
+    note?: string;
+}
+declare const UpdateLoaderArgs_base: import("@nestjs/common").Type<Partial<Omit<CreateLoaderArgs, "locationId" | "typeId">>>;
+export declare class UpdateLoaderArgs extends UpdateLoaderArgs_base {
+    id: string;
+    isActive?: boolean;
+}
+export declare class CreateLoadersArgs {
+    typeKey: string;
+    locationId: string;
+    quantity: number;
+    length?: number;
+    width?: number;
+    height?: number;
+    sizeUnit?: string;
+    volume?: number;
+    volumeUnit?: string;
+    note?: string;
+}
+export {};