@rytass/wms-module-graphql 0.8.0 → 0.10.0

package/lib/registry/operation-registry.js

@@ -0,0 +1,136 @@
+import { RESOLVER_TYPE_METADATA, TypeMetadataStorage, RESOLVER_NAME_METADATA } from '@nestjs/graphql';
+import { WMS_OPERATION_METADATA } from '../auth/wms-auth.types.js';
+
+function resolveDisabled(options) {
+    const { enabledOperations, disabledOperations, disabledFields } = options;
+    if (enabledOperations && disabledOperations) {
+        throw new Error('[wms-module-graphql] `enabledOperations` and `disabledOperations` are mutually exclusive — pass one or the other, not both.');
+    }
+    const enabled = enabledOperations ? new Set(enabledOperations) : null;
+    const disabled = disabledOperations
+        ? new Set(disabledOperations)
+        : null;
+    const fields = new Set(disabledFields ?? []);
+    return {
+        hasSwitches: enabled !== null || disabled !== null || fields.size > 0,
+        isOperationDisabled: (name) => {
+            if (enabled) {
+                return !enabled.has(name);
+            }
+            if (disabled) {
+                return disabled.has(name);
+            }
+            return false;
+        },
+        disabledFields: fields,
+    };
+}
+/** Methods already pruned, so the metadata filter can drop their entries. */
+const prunedMethods = new WeakMap();
+let metadataFilterInstalled = false;
+/**
+ * Stop the pruned operations from ever entering `TypeMetadataStorage`.
+ *
+ * The resolver metadata is **lazy**: `@Query()` / `@Mutation()` only register a
+ * thunk with `LazyMetadataStorage`, and the thunk calls `add*Metadata` when
+ * `GraphQLSchemaBuilder.build()` loads it. At `forRootAsync` time the storage
+ * arrays are therefore still empty, and filtering them then would remove
+ * nothing — so the filter has to sit on the writes instead.
+ */
+function installMetadataFilter() {
+    if (metadataFilterInstalled) {
+        return;
+    }
+    const storage = TypeMetadataStorage;
+    const addQuery = storage.addQueryMetadata.bind(storage);
+    const addMutation = storage.addMutationMetadata.bind(storage);
+    const isPruned = (metadata) => prunedMethods.get(metadata.target)?.has(metadata.methodName) === true;
+    storage.addQueryMetadata = (metadata) => {
+        if (isPruned(metadata)) {
+            return;
+        }
+        addQuery(metadata);
+    };
+    storage.addMutationMetadata = (metadata) => {
+        if (isPruned(metadata)) {
+            return;
+        }
+        addMutation(metadata);
+    };
+    metadataFilterInstalled = true;
+}
+/** The GraphQL field name a root handler ends up under. */
+function schemaNameOf(handler, methodName) {
+    const explicit = Reflect.getMetadata(RESOLVER_NAME_METADATA, handler);
+    return explicit || methodName;
+}
+/**
+ * Remove the switched-off root operations before the schema is built.
+ *
+ * Two edits are needed, at two different moments, and they must happen together:
+ *
+ * 1. **now** — `delete Resolver.prototype[method]`, because
+ *    `ResolversExplorerService.explore()` walks the prototype with
+ *    `MetadataScanner` and runs *before* the schema builder loads the lazy
+ *    metadata. Leaving the method in place would put `Query.foo` in the resolver
+ *    map with no matching field in the typeDefs, and `makeExecutableSchema`
+ *    rejects the whole schema (`requireResolversToMatchSchema`).
+ * 2. **at load time** — drop the metadata entry ({@link installMetadataFilter}),
+ *    or the SDL would still declare a field that resolves to `null`: present,
+ *    but dead.
+ *
+ * Deleting the prototype method does not disturb step 2's type reflection:
+ * `design:returntype` is stored against the prototype and property key, not
+ * against the function object, so it survives the delete.
+ *
+ * This runs synchronously from `forRootAsync`, i.e. while `AppModule` is still
+ * being defined. Both the classes and the storage are process-global, so a
+ * process may register `WmsModuleGraphqlModule` only once.
+ */
+function pruneDisabledOperations(resolverClasses, options) {
+    const { hasSwitches, isOperationDisabled, disabledFields } = resolveDisabled(options);
+    if (!hasSwitches) {
+        return { queries: [], mutations: [] };
+    }
+    installMetadataFilter();
+    const queries = [];
+    const mutations = [];
+    for (const resolverClass of resolverClasses) {
+        const prototype = resolverClass.prototype;
+        if (!prototype) {
+            continue;
+        }
+        for (const methodName of Object.getOwnPropertyNames(prototype)) {
+            if (methodName === 'constructor') {
+                continue;
+            }
+            const handler = prototype[methodName];
+            if (typeof handler !== 'function') {
+                continue;
+            }
+            const resolverType = Reflect.getMetadata(RESOLVER_TYPE_METADATA, handler);
+            // Only root operations are switchable. `@ResolveField` handlers are
+            // reached exclusively through an already-registered root field, so
+            // removing one would break the type rather than the deployment surface.
+            if (resolverType !== 'Query' && resolverType !== 'Mutation') {
+                continue;
+            }
+            const schemaName = schemaNameOf(handler, methodName);
+            const requirement = Reflect.getMetadata(WMS_OPERATION_METADATA, handler);
+            const disabled = disabledFields.has(schemaName) ||
+                (requirement !== undefined &&
+                    isOperationDisabled(`${requirement.resource}:${requirement.action}`));
+            if (!disabled) {
+                continue;
+            }
+            const alreadyPruned = prunedMethods.get(resolverClass) ?? new Set();
+            alreadyPruned.add(methodName);
+            prunedMethods.set(resolverClass, alreadyPruned);
+            delete prototype[methodName];
+            (resolverType === 'Query' ? queries : mutations).push(schemaName);
+        }
+    }
+    return { queries, mutations };
+}
+
+export { pruneDisabledOperations, resolveDisabled };

package/lib/resolvers/aggregated-stock.resolver.js

@@ -24,6 +24,7 @@ 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 '../dto/inventory-count-order.dto.js';
 import { StockService, WmsEntities, BatchGroupEntityClass, LoadersEntityClass } from '@rytass/wms-module-core';
 import { BatchDto } from '../dto/batch.dto.js';
 import { LocationDto } from '../dto/location.dto.js';

package/lib/resolvers/change-log.resolver.js

@@ -24,6 +24,7 @@ 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 '../dto/inventory-count-order.dto.js';
 import { StockEntityClass, WmsEntities, BatchGroupEntityClass } from '@rytass/wms-module-core';
 import { LocationDto } from '../dto/location.dto.js';
 import { BatchDto } from '../dto/batch.dto.js';

package/lib/resolvers/inventory-count-order.resolver.d.ts

@@ -0,0 +1,34 @@
+import { BatchEntityClass, InventoryCountOrderItemEntityClass, InventoryCountOrderLocationEntityClass, LoadersEntityClass, LocationEntityClass, MaterialEntityClass, WmsEntities } from '@rytass/wms-module-core';
+import { InventoryCountOrderDto, InventoryCountOrderItemDto } from '../dto/inventory-count-order.dto';
+import { BatchDto } from '../dto/batch.dto';
+import { LoaderDto } from '../dto/loader.dto';
+import { LocationDto } from '../dto/location.dto';
+import { MaterialDto } from '../dto/material.dto';
+import { type LoaderType } from '../helpers';
+export declare class InventoryCountOrderResolver {
+    private readonly entities;
+    constructor(entities: WmsEntities);
+    items({ id }: InventoryCountOrderDto, { loaders }: LoaderType<InventoryCountOrderItemEntityClass>): Promise<InventoryCountOrderItemDto[]>;
+    /**
+     * The locations the user picked.
+     *
+     * Only the roots: the scope table also holds every descendant the backend
+     * expanded into, and listing a whole aisle's shelves as chips would bury the
+     * one thing the operator actually chose. The expansion still exists in the
+     * database — it is what the lock reads — it just is not this field.
+     */
+    locations({ id }: InventoryCountOrderDto, { loaders }: LoaderType<InventoryCountOrderLocationEntityClass>): Promise<LocationDto[]>;
+}
+export declare class InventoryCountOrderItemResolver {
+    private readonly entities;
+    /**
+     * The configured entities, not the built-in classes: `__entity` decides which
+     * repository the DataLoader opens, so it has to follow whatever the consumer
+     * passed to `WMSBaseModuleOptions`.
+     */
+    constructor(entities: WmsEntities);
+    material({ materialId }: InventoryCountOrderItemDto, { loaders }: LoaderType<MaterialEntityClass>): Promise<MaterialDto>;
+    batch({ batchId }: InventoryCountOrderItemDto, { loaders }: LoaderType<BatchEntityClass>): Promise<BatchDto>;
+    location({ locationId }: InventoryCountOrderItemDto, { loaders }: LoaderType<LocationEntityClass>): Promise<LocationDto> | null;
+    loader({ loaderId }: InventoryCountOrderItemDto, { loaders }: LoaderType<LoadersEntityClass>): Promise<LoaderDto> | null;
+}

package/lib/resolvers/inventory-count-order.resolver.js

@@ -0,0 +1,148 @@
+import { __decorate, __param, __metadata } from 'tslib';
+import { ResolveField, Parent, Context, Resolver } from '@nestjs/graphql';
+import { WmsEntities, InventoryCountOrderItemEntityClass, InventoryCountOrderLocationEntityClass, BatchGroupEntityClass, LoadersEntityClass } from '@rytass/wms-module-core';
+import { InventoryCountOrderItemDto, InventoryCountOrderDto } from '../dto/inventory-count-order.dto.js';
+import { BatchDto } from '../dto/batch.dto.js';
+import { LoaderDto } from '../dto/loader.dto.js';
+import { LocationDto } from '../dto/location.dto.js';
+import { MaterialDto } from '../dto/material.dto.js';
+
+let InventoryCountOrderResolver = class InventoryCountOrderResolver {
+    entities;
+    constructor(entities) {
+        this.entities = entities;
+    }
+    items({ id }, { loaders }) {
+        return loaders.batchMany.load({
+            __entity: InventoryCountOrderItemEntityClass,
+            __from: { orderId: id },
+        });
+    }
+    /**
+     * The locations the user picked.
+     *
+     * Only the roots: the scope table also holds every descendant the backend
+     * expanded into, and listing a whole aisle's shelves as chips would bury the
+     * one thing the operator actually chose. The expansion still exists in the
+     * database — it is what the lock reads — it just is not this field.
+     */
+    async locations({ id }, { loaders }) {
+        const scope = (await loaders.batchMany.load({
+            __entity: InventoryCountOrderLocationEntityClass,
+            __from: { orderId: id },
+        }));
+        // The join rows carry `locationId`, not a loaded `location` relation, so
+        // each one has to go back through the location DataLoader. Returning
+        // `row.location` directly yields `undefined`, and the non-nullable list then
+        // fails the whole query with "Cannot return null for non-nullable field".
+        return Promise.all(scope
+            .filter(({ isRoot }) => isRoot)
+            .map(({ locationId }) => loaders.batchSingle.load({
+            __entity: this.entities.location,
+            __from: { id: locationId },
+        })));
+    }
+};
+__decorate([
+    ResolveField(() => [InventoryCountOrderItemDto]),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [InventoryCountOrderDto, Object]),
+    __metadata("design:returntype", Promise)
+], InventoryCountOrderResolver.prototype, "items", null);
+__decorate([
+    ResolveField(() => [LocationDto]),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [InventoryCountOrderDto, Object]),
+    __metadata("design:returntype", Promise)
+], InventoryCountOrderResolver.prototype, "locations", null);
+InventoryCountOrderResolver = __decorate([
+    Resolver(() => InventoryCountOrderDto),
+    __metadata("design:paramtypes", [WmsEntities])
+], InventoryCountOrderResolver);
+let InventoryCountOrderItemResolver = class InventoryCountOrderItemResolver {
+    entities;
+    /**
+     * The configured entities, not the built-in classes: `__entity` decides which
+     * repository the DataLoader opens, so it has to follow whatever the consumer
+     * passed to `WMSBaseModuleOptions`.
+     */
+    constructor(entities) {
+        this.entities = entities;
+    }
+    material({ materialId }, { loaders }) {
+        return loaders.batchSingle.load({
+            __entity: this.entities.material,
+            __from: { id: materialId },
+        });
+    }
+    async batch({ batchId }, { loaders }) {
+        const { groupId } = await loaders.batchSingle.load({
+            __entity: this.entities.batch,
+            __from: { id: batchId },
+        });
+        return loaders.batchSingle.load({
+            __entity: BatchGroupEntityClass,
+            __from: { id: groupId },
+        });
+    }
+    location({ locationId }, { loaders }) {
+        if (!locationId) {
+            return null;
+        }
+        return loaders.batchSingle.load({
+            __entity: this.entities.location,
+            __from: { id: locationId },
+        });
+    }
+    loader({ loaderId }, { loaders }) {
+        if (!loaderId) {
+            return null;
+        }
+        return loaders.batchSingle.load({
+            __entity: LoadersEntityClass,
+            __from: { id: loaderId },
+        });
+    }
+};
+__decorate([
+    ResolveField(() => MaterialDto),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [InventoryCountOrderItemDto, Object]),
+    __metadata("design:returntype", Promise)
+], InventoryCountOrderItemResolver.prototype, "material", null);
+__decorate([
+    ResolveField(() => BatchDto),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [InventoryCountOrderItemDto, Object]),
+    __metadata("design:returntype", Promise)
+], InventoryCountOrderItemResolver.prototype, "batch", null);
+__decorate([
+    ResolveField(() => LocationDto, { nullable: true }),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [InventoryCountOrderItemDto, Object]),
+    __metadata("design:returntype", Object)
+], InventoryCountOrderItemResolver.prototype, "location", null);
+__decorate([
+    ResolveField(() => LoaderDto, { nullable: true }),
+    __param(0, Parent()),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [InventoryCountOrderItemDto, Object]),
+    __metadata("design:returntype", Object)
+], InventoryCountOrderItemResolver.prototype, "loader", null);
+InventoryCountOrderItemResolver = __decorate([
+    Resolver(() => InventoryCountOrderItemDto),
+    __metadata("design:paramtypes", [WmsEntities])
+], InventoryCountOrderItemResolver);
+
+export { InventoryCountOrderItemResolver, InventoryCountOrderResolver };

package/lib/resolvers/loader-type.resolver.js

@@ -24,6 +24,7 @@ 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 '../dto/inventory-count-order.dto.js';
 import { LoaderTypeEntityClass, LoadersEntityClass } from '@rytass/wms-module-core';
 
 let LoaderTypeResolver = class LoaderTypeResolver {

package/lib/resolvers/loader.resolver.js

@@ -24,6 +24,7 @@ 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 '../dto/inventory-count-order.dto.js';
 import { LoadersEntityClass, WmsEntities, StockService, LoaderTypeEntityClass } from '@rytass/wms-module-core';
 import { LocationDto } from '../dto/location.dto.js';
 import _ from 'lodash';

package/lib/resolvers/material.resolver.js

@@ -24,6 +24,7 @@ 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 '../dto/inventory-count-order.dto.js';
 import { MaterialEntityClass, StockService, MaterialUnitEntityClass, UnitEntityClass } from '@rytass/wms-module-core';
 import { UnitDto } from '../dto/unit.dto.js';
 

package/lib/resolvers/receive-inventory-order.resolver.js

@@ -24,6 +24,7 @@ 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 '../dto/inventory-count-order.dto.js';
 import { ReceiveInventoryOrderItemEntityClass, WmsEntities, BatchGroupEntityClass, LoadersEntityClass, ReceiveInventoryOrderChangeEntityClass } from '@rytass/wms-module-core';
 import { BatchDto } from '../dto/batch.dto.js';
 import { LocationDto } from '../dto/location.dto.js';

package/lib/resolvers/ship-inventory-order.resolver.js

@@ -24,6 +24,7 @@ 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 '../dto/inventory-count-order.dto.js';
 import { ShipInventoryOrderEntityClass, ShipInventoryOrderItemEntityClass, WmsEntities, ShipInventoryOrderReferenceEntityClass, BatchGroupEntityClass, LoadersEntityClass, ShipInventoryOrderChangeEntityClass } from '@rytass/wms-module-core';
 import { BatchDto } from '../dto/batch.dto.js';
 import { LocationDto } from '../dto/location.dto.js';

package/lib/resolvers/stock.resolver.js

@@ -24,6 +24,7 @@ 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 '../dto/inventory-count-order.dto.js';
 import { StockEntityClass, WmsEntities, BatchGroupEntityClass } from '@rytass/wms-module-core';
 import { LocationDto } from '../dto/location.dto.js';
 import { BatchDto } from '../dto/batch.dto.js';

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

@@ -25,6 +25,7 @@ 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 '../dto/inventory-count-order.dto.js';
 import { BatchDto } from '../dto/batch.dto.js';
 import { LocationDto } from '../dto/location.dto.js';
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rytass/wms-module-graphql",
-  "version": "0.8.0",
+  "version": "0.10.0",
   "description": "Rytass WMS Module — GraphQL schema, resolvers and DTOs for warehouse management",
   "keywords": [
     "rytass",
@@ -30,10 +30,12 @@
     },
     "./adapters/member-base": {
       "types": "./adapters/member-base.d.ts",
+      "require": "./adapters/member-base.cjs.js",
       "import": "./adapters/member-base.js"
     },
     "./adapters/event-emitter": {
       "types": "./adapters/event-emitter.d.ts",
+      "require": "./adapters/event-emitter.cjs.js",
       "import": "./adapters/event-emitter.js"
     },
     "./package.json": "./package.json"
@@ -50,17 +52,21 @@
   },
   "dependencies": {
     "dataloader": "^2.2.3",
-    "lru-cache": "^10.0.0"
+    "lodash": "^4.17.0",
+    "lru-cache": "^10.0.0 || ^11.0.0"
   },
   "peerDependencies": {
     "@as-integrations/express5": "^1.0.0",
-    "@nestjs/apollo": ">=13.0.0 <13.2.0",
-    "@nestjs/common": "^11.0.0",
+    "@nestjs/apollo": "^13.0.0",
+    "@nestjs/common": "^10.0.0 || ^11.0.0",
+    "@nestjs/core": "^10.0.0 || ^11.0.0",
     "@nestjs/graphql": "^13.0.0",
-    "@rytass/wms-module-core": "^0.5.0",
+    "@rytass/wms-base-nestjs-module": "^0.4.0",
+    "@rytass/wms-module-core": "^0.7.0",
     "graphql": "^16.0.0",
     "reflect-metadata": "^0.1.13 || ^0.2.0",
-    "rxjs": "^7.8.0",
+    "rxjs": "^7.0.0",
+    "typeorm": "^0.3.0",
     "@nestjs/event-emitter": "^2.0.0 || ^3.0.0"
   },
   "peerDependenciesMeta": {