@rytass/wms-module-graphql 0.11.0 → 0.12.0

package/lib/events/wms-mutation.interceptor.js

@@ -1,64 +0,0 @@
-import { __decorate, __param, __metadata } from 'tslib';
-import { Injectable, Optional, Inject } from '@nestjs/common';
-import { Reflector } from '@nestjs/core';
-import { GqlExecutionContext } from '@nestjs/graphql';
-import { WMS_ACTOR_EXTRACTOR, WmsOperationRunner } from '@rytass/wms-module-core';
-import { firstValueFrom, of } from 'rxjs';
-import { WMS_MUTATION_EVENT_METADATA } from './wms-mutation-event.constants.js';
-
-/**
- * Hands each `@WmsMutationEvent` mutation to {@link WmsOperationRunner}, which
- * owns the before-hook / dispatch scope / post-commit flush sequence.
- *
- * All this adds on top is what only a GraphQL request can supply: the raw
- * arguments and the actor. Keeping the sequence itself in core is what stops
- * the GraphQL path and a host's direct service call from drifting apart.
- *
- * When no hook, listener or bridge is configured the runner passes through
- * untouched.
- */
-let WmsMutationInterceptor = class WmsMutationInterceptor {
-    reflector;
-    runner;
-    actorExtractor;
-    constructor(reflector, runner, actorExtractor = null) {
-        this.reflector = reflector;
-        this.runner = runner;
-        this.actorExtractor = actorExtractor;
-    }
-    resolveActor(context) {
-        if (!this.actorExtractor) {
-            return null;
-        }
-        try {
-            return this.actorExtractor(context);
-        }
-        catch {
-            // Fail-open on actor resolution: never break a mutation over audit metadata.
-            return null;
-        }
-    }
-    async intercept(context, next) {
-        const config = this.reflector.get(WMS_MUTATION_EVENT_METADATA, context.getHandler());
-        if (!config) {
-            return next.handle();
-        }
-        const result = await this.runner.run({
-            event: config.event,
-            args: GqlExecutionContext.create(context).getArgs() ?? {},
-            actor: this.resolveActor(context),
-            resolveId: config.resolveId,
-            executionContext: context,
-        }, () => firstValueFrom(next.handle()));
-        return of(result);
-    }
-};
-WmsMutationInterceptor = __decorate([
-    Injectable(),
-    __param(2, Optional()),
-    __param(2, Inject(WMS_ACTOR_EXTRACTOR)),
-    __metadata("design:paramtypes", [Reflector,
-        WmsOperationRunner, Object])
-], WmsMutationInterceptor);
-
-export { WmsMutationInterceptor };

package/lib/graphql.module.js

@@ -1,183 +0,0 @@
-import { __decorate } from 'tslib';
-import { Module } from '@nestjs/common';
-import { WmsModuleCoreModule } from '@rytass/wms-module-core';
-import './helpers/loader.service.js';
-import { HelperModule } from './helpers/helper.module.js';
-import './helpers/query-path.js';
-import { WmsAuthGuard } from './auth/wms-auth.guard.js';
-import { WMS_AUTH_OPTIONS } from './auth/wms-auth.types.js';
-import { WmsMutationInterceptor } from './events/wms-mutation.interceptor.js';
-import { pruneDisabledOperations } from './registry/operation-registry.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 { OrderReferenceQuery } from './queries/order-reference.query.js';
-import { OrderReferenceMutation } from './mutations/order-reference.mutation.js';
-import { ConsumptionOrderQuery } from './queries/consumption-order.query.js';
-import { ConsumptionOrderMutation } from './mutations/consumption-order.mutation.js';
-import { ConsumptionOrderResolver, ConsumptionOrderItemResolver } from './resolvers/consumption-order.resolver.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';
-import { InventoryCountOrderQuery } from './queries/inventory-count-order.query.js';
-import { InventoryCountOrderMutation } from './mutations/inventory-count-order.mutation.js';
-import { InventoryCountOrderResolver, InventoryCountOrderItemResolver } from './resolvers/inventory-count-order.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,
-    InventoryCountOrderQuery,
-    InventoryCountOrderMutation,
-    InventoryCountOrderResolver,
-    InventoryCountOrderItemResolver,
-    OrderReferenceQuery,
-    OrderReferenceMutation,
-    ConsumptionOrderQuery,
-    ConsumptionOrderMutation,
-    ConsumptionOrderResolver,
-    ConsumptionOrderItemResolver,
-];
-let WmsModuleGraphqlModule = WmsModuleGraphqlModule_1 = class WmsModuleGraphqlModule {
-    static forRootAsync(options) {
-        const { authChecker, beforeHooks, afterListeners, actorExtractor, eventEmitterBridge, enabledOperations, disabledOperations, disabledFields, ...coreOptions } = options;
-        // Must run before `GraphQLModule` builds the schema. `forRootAsync` is
-        // called while `AppModule` is still being defined, so this is the earliest
-        // point at which the deployment's switches are known — and it is early
-        // enough: the schema is not built until the app bootstraps.
-        pruneDisabledOperations(exportDependencies, {
-            enabledOperations,
-            disabledOperations,
-            disabledFields,
-        });
-        /*
-         * The event wiring goes down to the core module rather than being bound
-         * here. `WmsOperationRunner` lives in core so a host calling a service
-         * directly gets the same guarantee, and binding the same tokens in both
-         * modules would leave two live bindings whose winner depends on which
-         * injector the consumer reached first.
-         *
-         * `coreOptions` still carries `enrichStockEvents`, also forwarded.
-         */
-        const coreModule = WmsModuleCoreModule.forRootAsync({
-            ...coreOptions,
-            // The typed hook maps are a compile-time refinement of the core maps; at
-            // runtime the dispatched payload IS the concrete result type, so handing
-            // the refined maps to the (looser) core option contract is sound.
-            beforeHooks: beforeHooks,
-            afterListeners: afterListeners,
-            actorExtractor,
-            eventEmitterBridge,
-        });
-        const authOptions = { authChecker };
-        const providers = [
-            ...exportDependencies,
-            WmsAuthGuard,
-            { provide: WMS_AUTH_OPTIONS, useValue: authOptions },
-            WmsMutationInterceptor,
-        ];
-        return {
-            module: WmsModuleGraphqlModule_1,
-            imports: [coreModule, HelperModule],
-            providers,
-            exports: [...exportDependencies, WmsAuthGuard, HelperModule, coreModule],
-        };
-    }
-};
-WmsModuleGraphqlModule = WmsModuleGraphqlModule_1 = __decorate([
-    Module({
-        providers: exportDependencies,
-    })
-], WmsModuleGraphqlModule);
-
-export { WmsModuleGraphqlModule };

package/lib/helpers/create-wms-loaders.js

@@ -1,11 +0,0 @@
-function createWmsLoaders(loaderService) {
-    return {
-        loaders: {
-            batchSingle: loaderService.batchEntity(),
-            batchMany: loaderService.batchEntities(),
-            batchManyWithPagination: loaderService.batchEntitiesWithPagination(),
-        },
-    };
-}
-
-export { createWmsLoaders };

package/lib/helpers/helper.module.js

@@ -1,15 +0,0 @@
-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/loader.service.js

@@ -1,230 +0,0 @@
-import { __decorate, __metadata } from 'tslib';
-import { Injectable } from '@nestjs/common';
-import { createHash } from 'crypto';
-import _ from 'lodash';
-import { LRUCache } from 'lru-cache';
-import { DataSource, Brackets, 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('_')}`;
-    }
-    /**
-     * resolve a `__from` property name to the physical column it is stored in.
-     *
-     * TypeORM's `FindOptionsWhere` only accepts real column properties. A
-     * `@RelationId()` property — e.g. `LocationEntityClass.parentId`, which mirrors
-     * the `parent` tree relation — is virtual and is rejected with
-     * `EntityPropertyNotFoundError`, even though it is backed by the relation's
-     * join column. Map those back to their join column so they stay batchable.
-     * @param EntityMetadata
-     * @param string
-     * @returns string | null
-     */
-    resolveColumnName(metadata, propertyName) {
-        const column = metadata.findColumnWithPropertyName(propertyName);
-        if (column)
-            return column.databaseName;
-        const relationId = metadata.relationIds.find((candidate) => candidate.propertyName === propertyName);
-        const joinColumns = relationId?.relation.joinColumns ?? [];
-        return joinColumns.length === 1 ? joinColumns[0].databaseName : null;
-    }
-    /**
-     * build the where clause for `__from` keys that TypeORM's find options cannot
-     * express (see {@link resolveColumnName}), by addressing the columns directly.
-     * @param SelectQueryBuilder
-     * @param EntityMetadata
-     * @param LoaderOptions[]
-     * @param (keyof T)[]
-     */
-    applyColumnWhere(qb, metadata, options, primaryKeys) {
-        const columns = primaryKeys.map((primaryKey) => {
-            const columnName = this.resolveColumnName(metadata, String(primaryKey));
-            if (!columnName)
-                throw new Error(`Loader cannot resolve property "${String(primaryKey)}" to a column of "${metadata.name}".`);
-            return {
-                primaryKey,
-                column: `entity.${this.dataSource.driver.escape(columnName)}`,
-            };
-        });
-        if (columns.length === 1) {
-            const [{ primaryKey, column }] = columns;
-            qb.andWhere(`${column} IN (:...wmsLoaderValues)`, {
-                wmsLoaderValues: options.map(({ __from }) => __from[primaryKey]),
-            });
-            return;
-        }
-        qb.andWhere(new Brackets((where) => {
-            options.forEach(({ __from }, optionIndex) => {
-                const parameters = {};
-                const predicate = columns
-                    .map(({ primaryKey, column }, columnIndex) => {
-                    const parameter = `wmsLoaderValue_${optionIndex}_${columnIndex}`;
-                    parameters[parameter] = __from[primaryKey];
-                    return `${column} = :${parameter}`;
-                })
-                    .join(' AND ');
-                where.orWhere(`(${predicate})`, parameters);
-            });
-        }));
-    }
-    /**
-     * 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);
-        const hasVirtualKey = primaryKeys.some((primaryKey) => !repo.metadata.findColumnWithPropertyName(String(primaryKey)));
-        if (hasVirtualKey)
-            this.applyColumnWhere(qb, repo.metadata, options, primaryKeys);
-        else 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.js

@@ -1,19 +0,0 @@
-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.js

@@ -1,20 +0,0 @@
-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.js

@@ -1,23 +0,0 @@
-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 };