@rytass/wms-module-graphql 0.3.0 → 0.5.0

package/index.d.ts

@@ -3,3 +3,7 @@ export { LoaderService } from './lib/helpers/loader.service';
 export type { LoaderOptions, LoaderOptionsWithPagination, } from './lib/helpers/loader.service';
 export type { LoaderType } from './lib/helpers/dataloader.type';
 export { createWmsLoaders, type WmsLoaders, } from './lib/helpers/create-wms-loaders';
+export { HOST_SKIP_METADATA_KEY, WmsAuthGuard, WmsOperation, WMS_AUTH_OPTIONS, WMS_OPERATION_METADATA, type WmsAuthChecker, type WmsAuthModuleOptions, type WmsOperationRequirement, } from './lib/auth';
+export type { WmsModuleGraphqlModuleAsyncOptions } from './lib/graphql.module';
+export { WmsMutationEvent, WmsMutationInterceptor, WMS_MUTATION_EVENT_METADATA, type WmsMutationEventConfig, } from './lib/events';
+export type { WmsAfterEventContext, WmsAfterListener, WmsAfterListenerMap, WmsBeforeHook, WmsBeforeHookContext, WmsBeforeHookMap, WmsDomainEvent, WmsEventModuleOptions, WmsEventName, WmsEventPayloadMap, WmsOperationEventName, WmsOperationEventPayload, WmsStockEventName, WmsStockEventPayload, } from '@rytass/wms-module-core';

package/index.js

@@ -1,3 +1,10 @@
 export { WmsModuleGraphqlModule } from './lib/graphql.module.js';
 export { LoaderService } from './lib/helpers/loader.service.js';
 export { createWmsLoaders } from './lib/helpers/create-wms-loaders.js';
+export { HOST_SKIP_METADATA_KEY } from './lib/auth/host-skip.constant.js';
+export { WmsAuthGuard } from './lib/auth/wms-auth.guard.js';
+export { WmsOperation } from './lib/auth/wms-operation.decorator.js';
+export { WMS_AUTH_OPTIONS, WMS_OPERATION_METADATA } from './lib/auth/wms-auth.types.js';
+export { WmsMutationEvent } from './lib/events/wms-mutation-event.decorator.js';
+export { WMS_MUTATION_EVENT_METADATA } from './lib/events/wms-mutation-event.constants.js';
+export { WmsMutationInterceptor } from './lib/events/wms-mutation.interceptor.js';

package/lib/auth/host-skip.constant.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Metadata key stamped on every `@WmsOperation` handler so that a host
+ * application's *globally registered* auth guard (`APP_GUARD`) treats WMS
+ * resolvers as "skip / public" and defers the real authorization decision to
+ * {@link WmsAuthGuard}.
+ *
+ * Why this exists
+ * ---------------
+ * A deny-by-default global guard — e.g. the `CasbinGuard` from
+ * `@rytass/member-base-nestjs-module` — blankets every resolver in the compiled
+ * schema, including the ones this library owns. WMS resolvers carry no
+ * host-specific permission metadata, so such a guard rejects them all. By
+ * stamping this key WMS tells the host guard "let me through", and then runs
+ * its own {@link WmsAuthGuard} (wired to the consumer's `authChecker`) to do the
+ * actual enforcement.
+ *
+ * The single coupling point
+ * -------------------------
+ * The default value matches `@rytass/member-base-nestjs-module`'s
+ * `IS_ROUTE_PUBLIC` metadata key. This is the *one and only* place WMS assumes
+ * anything about a specific host guard. If your host guard uses a different
+ * "public / skip" metadata key, fork this constant — nothing else changes.
+ *
+ * If you do not register a global guard at all (or set
+ * `enableGlobalGuard: false`), this marker is simply inert.
+ */
+export declare const HOST_SKIP_METADATA_KEY = "IS_ROUTE_PUBLIC";

package/lib/auth/host-skip.constant.js

@@ -0,0 +1,29 @@
+/**
+ * Metadata key stamped on every `@WmsOperation` handler so that a host
+ * application's *globally registered* auth guard (`APP_GUARD`) treats WMS
+ * resolvers as "skip / public" and defers the real authorization decision to
+ * {@link WmsAuthGuard}.
+ *
+ * Why this exists
+ * ---------------
+ * A deny-by-default global guard — e.g. the `CasbinGuard` from
+ * `@rytass/member-base-nestjs-module` — blankets every resolver in the compiled
+ * schema, including the ones this library owns. WMS resolvers carry no
+ * host-specific permission metadata, so such a guard rejects them all. By
+ * stamping this key WMS tells the host guard "let me through", and then runs
+ * its own {@link WmsAuthGuard} (wired to the consumer's `authChecker`) to do the
+ * actual enforcement.
+ *
+ * The single coupling point
+ * -------------------------
+ * The default value matches `@rytass/member-base-nestjs-module`'s
+ * `IS_ROUTE_PUBLIC` metadata key. This is the *one and only* place WMS assumes
+ * anything about a specific host guard. If your host guard uses a different
+ * "public / skip" metadata key, fork this constant — nothing else changes.
+ *
+ * If you do not register a global guard at all (or set
+ * `enableGlobalGuard: false`), this marker is simply inert.
+ */
+const HOST_SKIP_METADATA_KEY = 'IS_ROUTE_PUBLIC';
+
+export { HOST_SKIP_METADATA_KEY };

package/lib/auth/index.d.ts

@@ -0,0 +1,4 @@
+export { HOST_SKIP_METADATA_KEY } from './host-skip.constant';
+export { WmsAuthGuard } from './wms-auth.guard';
+export { WmsOperation } from './wms-operation.decorator';
+export { WMS_AUTH_OPTIONS, WMS_OPERATION_METADATA, type WmsAuthChecker, type WmsAuthModuleOptions, type WmsOperationRequirement, } from './wms-auth.types';

package/lib/auth/wms-auth.guard.d.ts

@@ -0,0 +1,19 @@
+import { type CanActivate, type ExecutionContext } from '@nestjs/common';
+import { Reflector } from '@nestjs/core';
+import { type WmsAuthModuleOptions } from './wms-auth.types';
+/**
+ * Route-level guard applied automatically by `@WmsOperation`. It reads the
+ * requirement declared on the handler and delegates the allow/deny decision to
+ * the consumer-supplied {@link WmsAuthModuleOptions.authChecker}.
+ *
+ * It is deliberately permissive in two cases:
+ * - the handler carries no requirement (field resolvers reached only through an
+ *   already-authorized root operation), and
+ * - no `authChecker` was configured (local dev / auth handled elsewhere).
+ */
+export declare class WmsAuthGuard implements CanActivate {
+    private readonly reflector;
+    private readonly options;
+    constructor(reflector: Reflector, options: WmsAuthModuleOptions);
+    canActivate(context: ExecutionContext): boolean | Promise<boolean>;
+}

package/lib/auth/wms-auth.guard.js

@@ -0,0 +1,41 @@
+import { __decorate, __param, __metadata } from 'tslib';
+import { Injectable, Inject } from '@nestjs/common';
+import { Reflector } from '@nestjs/core';
+import { WMS_AUTH_OPTIONS, WMS_OPERATION_METADATA } from './wms-auth.types.js';
+
+/**
+ * Route-level guard applied automatically by `@WmsOperation`. It reads the
+ * requirement declared on the handler and delegates the allow/deny decision to
+ * the consumer-supplied {@link WmsAuthModuleOptions.authChecker}.
+ *
+ * It is deliberately permissive in two cases:
+ * - the handler carries no requirement (field resolvers reached only through an
+ *   already-authorized root operation), and
+ * - no `authChecker` was configured (local dev / auth handled elsewhere).
+ */
+let WmsAuthGuard = class WmsAuthGuard {
+    reflector;
+    options;
+    constructor(reflector, options) {
+        this.reflector = reflector;
+        this.options = options;
+    }
+    canActivate(context) {
+        const requirement = this.reflector.get(WMS_OPERATION_METADATA, context.getHandler());
+        if (!requirement) {
+            return true;
+        }
+        const { authChecker } = this.options;
+        if (!authChecker) {
+            return true;
+        }
+        return authChecker(context, requirement);
+    }
+};
+WmsAuthGuard = __decorate([
+    Injectable(),
+    __param(1, Inject(WMS_AUTH_OPTIONS)),
+    __metadata("design:paramtypes", [Reflector, Object])
+], WmsAuthGuard);
+
+export { WmsAuthGuard };

package/lib/auth/wms-auth.types.d.ts

@@ -0,0 +1,36 @@
+import type { ExecutionContext } from '@nestjs/common';
+/**
+ * A single, host-neutral permission requirement attached to a WMS root
+ * operation. `resource` and `action` are plain strings on purpose — the WMS
+ * library never knows (nor cares) how a consumer maps them onto Casbin, RBAC
+ * tiers, JWT scopes or anything else. The mapping lives entirely in the
+ * consumer-supplied {@link WmsAuthChecker}.
+ */
+export interface WmsOperationRequirement {
+    readonly resource: string;
+    readonly action: string;
+}
+/**
+ * The authorization contract a consumer wires into
+ * `WmsModuleGraphqlModule.forRootAsync({ authChecker })`. It receives the live
+ * NestJS {@link ExecutionContext} (so the consumer can reach the request,
+ * GraphQL context, current member, enforcer, etc.) plus the requirement
+ * declared by `@WmsOperation` on the resolver being invoked.
+ *
+ * Return `true` to allow, `false` to deny. Throwing is also fine — the
+ * exception propagates exactly like any guard rejection.
+ */
+export type WmsAuthChecker = (context: ExecutionContext, requirement: WmsOperationRequirement) => boolean | Promise<boolean>;
+/**
+ * Options accepted by `WmsModuleGraphqlModule.forRootAsync` that govern
+ * authorization. Intentionally optional: when `authChecker` is omitted the
+ * module stays fully permissive, preserving the pre-auth release behaviour for
+ * local development and consumers that handle authorization elsewhere.
+ */
+export interface WmsAuthModuleOptions {
+    readonly authChecker?: WmsAuthChecker;
+}
+/** DI token holding the resolved {@link WmsAuthModuleOptions}. */
+export declare const WMS_AUTH_OPTIONS: unique symbol;
+/** Reflector metadata key carrying the {@link WmsOperationRequirement}. */
+export declare const WMS_OPERATION_METADATA = "wms:operation";

package/lib/auth/wms-auth.types.js

@@ -0,0 +1,6 @@
+/** DI token holding the resolved {@link WmsAuthModuleOptions}. */
+const WMS_AUTH_OPTIONS = Symbol('WMS_AUTH_OPTIONS');
+/** Reflector metadata key carrying the {@link WmsOperationRequirement}. */
+const WMS_OPERATION_METADATA = 'wms:operation';
+
+export { WMS_AUTH_OPTIONS, WMS_OPERATION_METADATA };

package/lib/auth/wms-operation.decorator.d.ts

@@ -0,0 +1,23 @@
+import { type WmsOperationRequirement } from './wms-auth.types';
+/**
+ * Declares the permission requirement for a WMS root operation and wires up its
+ * enforcement. Apply it to every `@Query` / `@Mutation` the library exposes.
+ *
+ * It bundles three concerns so a single annotation keeps a resolver
+ * self-protecting and host-friendly:
+ *
+ * 1. {@link WMS_OPERATION_METADATA} — the host-neutral `{ resource, action }`
+ *    that {@link WmsAuthGuard} hands to the consumer's `authChecker`.
+ * 2. {@link HOST_SKIP_METADATA_KEY} — tells a host's global guard to defer (see
+ *    that constant for the single coupling point with member-base).
+ * 3. `@UseGuards(WmsAuthGuard)` — the route-level guard that performs the real
+ *    authorization through the configured `authChecker`.
+ *
+ * @example
+ * ```ts
+ * @Query(() => MaterialDto)
+ * @WmsOperation({ resource: 'material', action: 'read' })
+ * material(@Args('id') id: string): Promise<MaterialDto> { ... }
+ * ```
+ */
+export declare const WmsOperation: (requirement: WmsOperationRequirement) => MethodDecorator;

package/lib/auth/wms-operation.decorator.js

@@ -0,0 +1,29 @@
+import { applyDecorators, SetMetadata, UseGuards } from '@nestjs/common';
+import { HOST_SKIP_METADATA_KEY } from './host-skip.constant.js';
+import { WmsAuthGuard } from './wms-auth.guard.js';
+import { WMS_OPERATION_METADATA } from './wms-auth.types.js';
+
+/**
+ * Declares the permission requirement for a WMS root operation and wires up its
+ * enforcement. Apply it to every `@Query` / `@Mutation` the library exposes.
+ *
+ * It bundles three concerns so a single annotation keeps a resolver
+ * self-protecting and host-friendly:
+ *
+ * 1. {@link WMS_OPERATION_METADATA} — the host-neutral `{ resource, action }`
+ *    that {@link WmsAuthGuard} hands to the consumer's `authChecker`.
+ * 2. {@link HOST_SKIP_METADATA_KEY} — tells a host's global guard to defer (see
+ *    that constant for the single coupling point with member-base).
+ * 3. `@UseGuards(WmsAuthGuard)` — the route-level guard that performs the real
+ *    authorization through the configured `authChecker`.
+ *
+ * @example
+ * ```ts
+ * @Query(() => MaterialDto)
+ * @WmsOperation({ resource: 'material', action: 'read' })
+ * material(@Args('id') id: string): Promise<MaterialDto> { ... }
+ * ```
+ */
+const WmsOperation = (requirement) => applyDecorators(SetMetadata(WMS_OPERATION_METADATA, requirement), SetMetadata(HOST_SKIP_METADATA_KEY, true), UseGuards(WmsAuthGuard));
+
+export { WmsOperation };

package/lib/events/index.d.ts

@@ -0,0 +1,3 @@
+export { WmsMutationEvent } from './wms-mutation-event.decorator';
+export { WMS_MUTATION_EVENT_METADATA, type WmsMutationEventConfig, } from './wms-mutation-event.constants';
+export { WmsMutationInterceptor } from './wms-mutation.interceptor';

package/lib/events/wms-mutation-event.constants.d.ts

@@ -0,0 +1,12 @@
+import type { WmsOperationEventName } from '@rytass/wms-module-core';
+/** Reflector metadata key carrying the {@link WmsMutationEventConfig}. */
+export declare const WMS_MUTATION_EVENT_METADATA = "wms:mutation-event";
+export interface WmsMutationEventConfig {
+    /** The operation event emitted for this mutation (post-commit). */
+    readonly event: WmsOperationEventName;
+    /**
+     * Optional override for deriving the operation's primary id from the handler
+     * result and/or arguments. Defaults to `result.id ?? args.id ?? null`.
+     */
+    readonly resolveId?: (result: unknown, args: Readonly<Record<string, unknown>>) => string | null;
+}

package/lib/events/wms-mutation-event.constants.js

@@ -0,0 +1,4 @@
+/** Reflector metadata key carrying the {@link WmsMutationEventConfig}. */
+const WMS_MUTATION_EVENT_METADATA = 'wms:mutation-event';
+
+export { WMS_MUTATION_EVENT_METADATA };

package/lib/events/wms-mutation-event.decorator.d.ts

@@ -0,0 +1,15 @@
+import { type WmsMutationEventConfig } from './wms-mutation-event.constants';
+/**
+ * Declares the operation event for a WMS root mutation and wires the
+ * {@link WmsMutationInterceptor} that runs before-hooks (veto) and flushes
+ * collected events post-commit. Apply alongside `@WmsOperation` on each mutation.
+ *
+ * @example
+ * ```ts
+ * @Mutation(() => ShipInventoryOrderDto)
+ * @WmsOperation({ resource: 'ship-inventory-order', action: 'ship' })
+ * @WmsMutationEvent({ event: 'ship-inventory-order.shipped' })
+ * ship(@Args() args: ShipArgs): Promise<boolean> { ... }
+ * ```
+ */
+export declare const WmsMutationEvent: (config: WmsMutationEventConfig) => MethodDecorator;

package/lib/events/wms-mutation-event.decorator.js

@@ -0,0 +1,20 @@
+import { applyDecorators, SetMetadata, UseInterceptors } from '@nestjs/common';
+import { WMS_MUTATION_EVENT_METADATA } from './wms-mutation-event.constants.js';
+import { WmsMutationInterceptor } from './wms-mutation.interceptor.js';
+
+/**
+ * Declares the operation event for a WMS root mutation and wires the
+ * {@link WmsMutationInterceptor} that runs before-hooks (veto) and flushes
+ * collected events post-commit. Apply alongside `@WmsOperation` on each mutation.
+ *
+ * @example
+ * ```ts
+ * @Mutation(() => ShipInventoryOrderDto)
+ * @WmsOperation({ resource: 'ship-inventory-order', action: 'ship' })
+ * @WmsMutationEvent({ event: 'ship-inventory-order.shipped' })
+ * ship(@Args() args: ShipArgs): Promise<boolean> { ... }
+ * ```
+ */
+const WmsMutationEvent = (config) => applyDecorators(SetMetadata(WMS_MUTATION_EVENT_METADATA, config), UseInterceptors(WmsMutationInterceptor));
+
+export { WmsMutationEvent };

package/lib/events/wms-mutation.interceptor.d.ts

@@ -0,0 +1,19 @@
+import { type CallHandler, type ExecutionContext, type NestInterceptor } from '@nestjs/common';
+import { Reflector } from '@nestjs/core';
+import { WmsEventDispatcher } from '@rytass/wms-module-core';
+import { type Observable } from 'rxjs';
+/**
+ * Wraps each `@WmsMutationEvent` mutation in a dispatch scope:
+ * 1. runs the before-hook (throw -> veto, before any transaction);
+ * 2. executes the resolver (services collect stock events into the scope);
+ * 3. emits the operation event after the handler resolves (post-commit);
+ * 4. flushes the whole buffer to after-listeners + emitter bridge.
+ *
+ * When no hook/listener/bridge is configured it passes through untouched.
+ */
+export declare class WmsMutationInterceptor implements NestInterceptor {
+    private readonly reflector;
+    private readonly dispatcher;
+    constructor(reflector: Reflector, dispatcher: WmsEventDispatcher);
+    intercept(context: ExecutionContext, next: CallHandler): Promise<Observable<unknown>>;
+}

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

@@ -0,0 +1,72 @@
+import { __decorate, __metadata } from 'tslib';
+import { Injectable } from '@nestjs/common';
+import { Reflector } from '@nestjs/core';
+import { GqlExecutionContext } from '@nestjs/graphql';
+import { WmsEventDispatcher, runInDispatchScope, collectToScope } from '@rytass/wms-module-core';
+import { firstValueFrom, of } from 'rxjs';
+import { WMS_MUTATION_EVENT_METADATA } from './wms-mutation-event.constants.js';
+
+const defaultResolveId = (result, args) => {
+    if (result &&
+        typeof result === 'object' &&
+        'id' in result &&
+        typeof result.id === 'string') {
+        return result.id;
+    }
+    const argId = args['id'];
+    return typeof argId === 'string' ? argId : null;
+};
+/**
+ * Wraps each `@WmsMutationEvent` mutation in a dispatch scope:
+ * 1. runs the before-hook (throw -> veto, before any transaction);
+ * 2. executes the resolver (services collect stock events into the scope);
+ * 3. emits the operation event after the handler resolves (post-commit);
+ * 4. flushes the whole buffer to after-listeners + emitter bridge.
+ *
+ * When no hook/listener/bridge is configured it passes through untouched.
+ */
+let WmsMutationInterceptor = class WmsMutationInterceptor {
+    reflector;
+    dispatcher;
+    constructor(reflector, dispatcher) {
+        this.reflector = reflector;
+        this.dispatcher = dispatcher;
+    }
+    async intercept(context, next) {
+        const config = this.reflector.get(WMS_MUTATION_EVENT_METADATA, context.getHandler());
+        if (!config || !this.dispatcher.isActive()) {
+            return next.handle();
+        }
+        const args = GqlExecutionContext.create(context).getArgs() ??
+            {};
+        // Before-hook runs before any DB work; a throw vetoes with zero side effects.
+        await this.dispatcher.runBeforeHook({
+            event: config.event,
+            args,
+            executionContext: context,
+        });
+        const { result, events } = await runInDispatchScope(async () => {
+            const handlerResult = await firstValueFrom(next.handle());
+            const id = config.resolveId
+                ? config.resolveId(handlerResult, args)
+                : defaultResolveId(handlerResult, args);
+            const operationEvent = {
+                name: config.event,
+                payload: { id, result: handlerResult },
+            };
+            collectToScope(operationEvent);
+            return handlerResult;
+        });
+        if (events) {
+            await this.dispatcher.flush(events);
+        }
+        return of(result);
+    }
+};
+WmsMutationInterceptor = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [Reflector,
+        WmsEventDispatcher])
+], WmsMutationInterceptor);
+
+export { WmsMutationInterceptor };

package/lib/graphql.module.d.ts

@@ -1,5 +1,22 @@
-import { DynamicModule } from '@nestjs/common';
-import type { WmsModuleCoreModuleAsyncOptions } from '@rytass/wms-module-core';
+import { DynamicModule, type Provider } from '@nestjs/common';
+import { type WmsModuleCoreModuleAsyncOptions, type WmsEventModuleOptions } from '@rytass/wms-module-core';
+import { type WmsAuthModuleOptions } from './auth';
+/**
+ * Options for `WmsModuleGraphqlModule.forRootAsync`. Extends the core module
+ * options with:
+ * - {@link WmsAuthModuleOptions.authChecker} — opt-in resolver authorization;
+ * - {@link WmsEventModuleOptions} — `beforeHooks` (veto) / `afterListeners`
+ *   (post-commit notify) for the mutation event/hook system;
+ * - `eventEmitterBridge` — pass `wmsEventEmitterBridgeProvider` from
+ *   `@rytass/wms-module-graphql/adapters/event-emitter` to also fan events out
+ *   to `@nestjs/event-emitter` (`@OnEvent('wms.<event>')`).
+ *
+ * Everything is optional; with nothing configured the module behaves exactly as
+ * before (no events emitted, fully permissive).
+ */
+export type WmsModuleGraphqlModuleAsyncOptions = WmsModuleCoreModuleAsyncOptions & WmsAuthModuleOptions & WmsEventModuleOptions & {
+    readonly eventEmitterBridge?: Provider;
+};
 export declare class WmsModuleGraphqlModule {
-    static forRootAsync(options: WmsModuleCoreModuleAsyncOptions): DynamicModule;
+    static forRootAsync(options: WmsModuleGraphqlModuleAsyncOptions): DynamicModule;
 }

package/lib/graphql.module.js

@@ -1,9 +1,12 @@
 import { __decorate } from 'tslib';
 import { Module } from '@nestjs/common';
-import { WmsModuleCoreModule } from '@rytass/wms-module-core';
+import { WmsModuleCoreModule, WMS_EVENT_OPTIONS, WmsEventDispatcher } 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 { LoaderMutation } from './mutations/loader.mutation.js';
 import { LoaderQuery } from './queries/loader.query.js';
 import { MaterialMutation } from './mutations/material.mutation.js';
@@ -108,12 +111,24 @@ const exportDependencies = [
 ];
 let WmsModuleGraphqlModule = WmsModuleGraphqlModule_1 = class WmsModuleGraphqlModule {
     static forRootAsync(options) {
-        const coreModule = WmsModuleCoreModule.forRootAsync(options);
+        const { authChecker, beforeHooks, afterListeners, eventEmitterBridge, ...coreOptions } = options;
+        const coreModule = WmsModuleCoreModule.forRootAsync(coreOptions);
+        const authOptions = { authChecker };
+        const eventOptions = { beforeHooks, afterListeners };
+        const providers = [
+            ...exportDependencies,
+            WmsAuthGuard,
+            { provide: WMS_AUTH_OPTIONS, useValue: authOptions },
+            { provide: WMS_EVENT_OPTIONS, useValue: eventOptions },
+            WmsEventDispatcher,
+            WmsMutationInterceptor,
+            ...(eventEmitterBridge ? [eventEmitterBridge] : []),
+        ];
         return {
             module: WmsModuleGraphqlModule_1,
             imports: [coreModule, HelperModule],
-            providers: exportDependencies,
-            exports: [...exportDependencies, HelperModule, coreModule],
+            providers,
+            exports: [...exportDependencies, WmsAuthGuard, HelperModule, coreModule],
         };
     }
 };

package/lib/mutations/allocate-inventory-order.mutation.js

@@ -5,6 +5,10 @@ import { AllocateInventoryOrderService, StockService } from '@rytass/wms-module-
 import { AllocateInventoryOrderDto } from '../dto/allocate-inventory-order.dto.js';
 import { CreateAllocateInventoryOrderArgs, UpdateAllocateInventoryOrderArgs } from '../inputs/create-allocate-inventory-order.args.js';
 import { DeallocateOrderArgs } from '../inputs/deallocate-order.args.js';
+import '../auth/wms-auth.guard.js';
+import { WmsOperation } from '../auth/wms-operation.decorator.js';
+import { WmsMutationEvent } from '../events/wms-mutation-event.decorator.js';
+import '../events/wms-mutation.interceptor.js';
 
 let AllocateInventoryOrderMutation = class AllocateInventoryOrderMutation {
     allocateInventoryOrderService;
@@ -53,6 +57,8 @@ let AllocateInventoryOrderMutation = class AllocateInventoryOrderMutation {
 };
 __decorate([
     Mutation(() => AllocateInventoryOrderDto),
+    WmsOperation({ resource: 'allocate-inventory-order', action: 'create' }),
+    WmsMutationEvent({ event: 'allocate-inventory-order.created' }),
     __param(0, Args()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [CreateAllocateInventoryOrderArgs]),
@@ -60,6 +66,8 @@ __decorate([
 ], AllocateInventoryOrderMutation.prototype, "createAllocateInventoryOrder", null);
 __decorate([
     Mutation(() => AllocateInventoryOrderDto),
+    WmsOperation({ resource: 'allocate-inventory-order', action: 'update' }),
+    WmsMutationEvent({ event: 'allocate-inventory-order.updated' }),
     __param(0, Args()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [UpdateAllocateInventoryOrderArgs]),
@@ -67,6 +75,8 @@ __decorate([
 ], AllocateInventoryOrderMutation.prototype, "updateAllocateInventoryOrder", null);
 __decorate([
     Mutation(() => Boolean),
+    WmsOperation({ resource: 'allocate-inventory-order', action: 'deallocate' }),
+    WmsMutationEvent({ event: 'allocate-inventory-order.deallocated' }),
     __param(0, Args('items', { type: () => [DeallocateOrderArgs] })),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Array]),

package/lib/mutations/hold-inventory-order.mutation.js

@@ -5,6 +5,10 @@ import { HoldInventoryOrderService, StockService } from '@rytass/wms-module-core
 import { HoldInventoryOrderDto } from '../dto/hold-inventory-order.dto.js';
 import { CreateHoldInventoryOrderArgs, UpdateHoldInventoryOrderArgs } from '../inputs/create-hold-inventory-order.args.js';
 import { ReleaseOrderArgs } from '../inputs/release-order.args.js';
+import '../auth/wms-auth.guard.js';
+import { WmsOperation } from '../auth/wms-operation.decorator.js';
+import { WmsMutationEvent } from '../events/wms-mutation-event.decorator.js';
+import '../events/wms-mutation.interceptor.js';
 
 let HoldInventoryOrderMutation = class HoldInventoryOrderMutation {
     holdInventoryOrderService;
@@ -53,6 +57,8 @@ let HoldInventoryOrderMutation = class HoldInventoryOrderMutation {
 };
 __decorate([
     Mutation(() => HoldInventoryOrderDto),
+    WmsOperation({ resource: 'hold-inventory-order', action: 'create' }),
+    WmsMutationEvent({ event: 'hold-inventory-order.created' }),
     __param(0, Args()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [CreateHoldInventoryOrderArgs]),
@@ -60,6 +66,8 @@ __decorate([
 ], HoldInventoryOrderMutation.prototype, "createHoldInventoryOrder", null);
 __decorate([
     Mutation(() => HoldInventoryOrderDto),
+    WmsOperation({ resource: 'hold-inventory-order', action: 'update' }),
+    WmsMutationEvent({ event: 'hold-inventory-order.updated' }),
     __param(0, Args()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [UpdateHoldInventoryOrderArgs]),
@@ -67,6 +75,8 @@ __decorate([
 ], HoldInventoryOrderMutation.prototype, "updateHoldInventoryOrder", null);
 __decorate([
     Mutation(() => Boolean),
+    WmsOperation({ resource: 'hold-inventory-order', action: 'release' }),
+    WmsMutationEvent({ event: 'hold-inventory-order.released' }),
     __param(0, Args('items', { type: () => [ReleaseOrderArgs] })),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Array]),

package/lib/mutations/loader.mutation.js

@@ -29,6 +29,10 @@ import { Mutation, Args } from '@nestjs/graphql';
 import { CreateLoaderTypeArgs, UpdateLoaderTypeArgs } from '../inputs/create-loader-type.args.js';
 import { CreateLoaderArgs, CreateLoadersArgs, UpdateLoaderArgs } from '../inputs/create-loader.args.js';
 import { In } from 'typeorm';
+import '../auth/wms-auth.guard.js';
+import { WmsOperation } from '../auth/wms-operation.decorator.js';
+import { WmsMutationEvent } from '../events/wms-mutation-event.decorator.js';
+import '../events/wms-mutation.interceptor.js';
 
 let LoaderMutation = class LoaderMutation {
     loaderService;
@@ -64,6 +68,8 @@ let LoaderMutation = class LoaderMutation {
 };
 __decorate([
     Mutation(() => [LoaderDto]),
+    WmsOperation({ resource: 'loader', action: 'create' }),
+    WmsMutationEvent({ event: 'loader.created' }),
     __param(0, Args()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [CreateLoaderArgs]),
@@ -71,6 +77,8 @@ __decorate([
 ], LoaderMutation.prototype, "createLoader", null);
 __decorate([
     Mutation(() => [LoaderDto]),
+    WmsOperation({ resource: 'loader', action: 'create' }),
+    WmsMutationEvent({ event: 'loader.batch-created' }),
     __param(0, Args('items', { type: () => [CreateLoadersArgs] })),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Array]),
@@ -78,6 +86,8 @@ __decorate([
 ], LoaderMutation.prototype, "createBatchLoader", null);
 __decorate([
     Mutation(() => LoaderDto),
+    WmsOperation({ resource: 'loader', action: 'update' }),
+    WmsMutationEvent({ event: 'loader.updated' }),
     __param(0, Args()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [UpdateLoaderArgs]),
@@ -85,6 +95,8 @@ __decorate([
 ], LoaderMutation.prototype, "updateLoader", null);
 __decorate([
     Mutation(() => LoaderTypeDto),
+    WmsOperation({ resource: 'loader', action: 'create' }),
+    WmsMutationEvent({ event: 'loader.type-created' }),
     __param(0, Args()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [CreateLoaderTypeArgs]),
@@ -92,6 +104,8 @@ __decorate([
 ], LoaderMutation.prototype, "createLoaderType", null);
 __decorate([
     Mutation(() => LoaderTypeDto),
+    WmsOperation({ resource: 'loader', action: 'update' }),
+    WmsMutationEvent({ event: 'loader.type-updated' }),
     __param(0, Args()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [UpdateLoaderTypeArgs]),

package/lib/mutations/location.mutation.js

@@ -4,6 +4,10 @@ import { Mutation, Args } from '@nestjs/graphql';
 import { LocationService } from '@rytass/wms-module-core';
 import { LocationDto } from '../dto/location.dto.js';
 import { CreateLocationArgs, UpdateLocationArgs } from '../inputs/create-location.args.js';
+import '../auth/wms-auth.guard.js';
+import { WmsOperation } from '../auth/wms-operation.decorator.js';
+import { WmsMutationEvent } from '../events/wms-mutation-event.decorator.js';
+import '../events/wms-mutation.interceptor.js';
 
 let LocationMutation = class LocationMutation {
     locationService;
@@ -19,6 +23,8 @@ let LocationMutation = class LocationMutation {
 };
 __decorate([
     Mutation(() => LocationDto),
+    WmsOperation({ resource: 'location', action: 'create' }),
+    WmsMutationEvent({ event: 'location.created' }),
     __param(0, Args()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [CreateLocationArgs]),
@@ -26,6 +32,8 @@ __decorate([
 ], LocationMutation.prototype, "createLocation", null);
 __decorate([
     Mutation(() => LocationDto),
+    WmsOperation({ resource: 'location', action: 'update' }),
+    WmsMutationEvent({ event: 'location.updated' }),
     __param(0, Args()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [UpdateLocationArgs]),