feat(json-api-nestjs): Allow call interceptor for each operation in atomic endpoint

Author: klerick

apps/json-api-server/src/app/resources/service/atomic.interceptor.ts

@@ -0,0 +1,18 @@
+import {
+  CallHandler,
+  ExecutionContext,
+  NestInterceptor,
+  Injectable,
+} from '@nestjs/common';
+import { Observable } from 'rxjs';
+
+@Injectable()
+export class AtomicInterceptor<T> implements NestInterceptor {
+  intercept(context: ExecutionContext, next: CallHandler<T>): Observable<T> {
+    const isAtomic = context.getArgByIndex(3);
+    if (isAtomic) {
+      console.log('call from atomic operation');
+    }
+    return next.handle();
+  }
+}

libs/json-api/json-api-nestjs/README.md

@@ -409,4 +409,20 @@ but [Atomic operation](https://jsonapi.org/ext/atomic/) allow for one request.
 
 ```
 **tmpId** - is params for operation **add**, should be unique for all operations.
+If you have Interceptor you can check call it from **AtomicOperation**
 
+
+
+```ts
+@Injectable()
+export class AtomicInterceptor<T> implements NestInterceptor {
+  intercept(context: ExecutionContext, next: CallHandler<T>): Observable<T> {
+    const isAtomic = context.getArgByIndex(3)
+    if (isAtomic) {
+      console.log('call from atomic operation')
+    }
+    return next.handle();
+  }
+}
+```
+**isAtomic** - is array of params of method

libs/json-api/json-api-nestjs/src/lib/modules/atomic-operation/atomic-operation.module.ts

@@ -1,4 +1,11 @@
-import { DynamicModule, Module } from '@nestjs/common';
+import { AsyncLocalStorage } from 'async_hooks';
+import {
+  DynamicModule,
+  Inject,
+  MiddlewareConsumer,
+  Module,
+  NestModule,
+} from '@nestjs/common';
 import { DiscoveryModule } from '@nestjs/core';
 
 import { OperationController } from './controllers';
@@ -11,9 +18,10 @@ import {
   AsyncIterate,
 } from './factory';
 import { ModuleOptions } from '../../types';
+import { MAP_CONTROLLER_INTERCEPTORS, OPTIONS } from './constants';
 
 @Module({})
-export class AtomicOperationModule {
+export class AtomicOperationModule implements NestModule {
   static forRoot(
     options: ModuleOptions,
     entityModules: DynamicModule[],
@@ -30,8 +38,34 @@ export class AtomicOperationModule {
         MapControllerEntity(options.entities, entityModules),
         MapEntityNameToEntity(options.entities),
         ZodInputOperation(options.connectionName),
+        {
+          provide: MAP_CONTROLLER_INTERCEPTORS,
+          useValue: new Map(),
+        },
+        {
+          provide: OPTIONS,
+          useValue: options.options,
+        },
+        {
+          provide: AsyncLocalStorage,
+          useValue: new AsyncLocalStorage(),
+        },
       ],
       imports: [DiscoveryModule, commonModule],
     };
   }
+  @Inject(AsyncLocalStorage) private readonly als!: AsyncLocalStorage<any>;
+
+  configure(consumer: MiddlewareConsumer) {
+    consumer
+      .apply((req: any, res: any, next: any) => {
+        const store = {
+          req: req,
+          res: res,
+          next: next,
+        };
+        this.als.run(store, () => next());
+      })
+      .forRoutes('*');
+  }
 }

libs/json-api/json-api-nestjs/src/lib/modules/atomic-operation/constants/index.ts

@@ -1,6 +1,10 @@
 export const MAP_CONTROLLER_ENTITY = Symbol('MAP_CONTROLLER_ENTITY');
+export const MAP_CONTROLLER_INTERCEPTORS = Symbol(
+  'MAP_CONTROLLER_INTERCEPTORS'
+);
 export const MAP_ENTITY = Symbol('MAP_ENTITY');
 export const ZOD_INPUT_OPERATION = Symbol('ZOD_INPUT_OPERATION');
 export const ASYNC_ITERATOR_FACTORY = Symbol('ASYNC_ITERATOR_FACTORY');
 export const KEY_MAIN_INPUT_SCHEMA = 'atomic:operations';
 export const KEY_MAIN_OUTPUT_SCHEMA = 'atomic:results';
+export const OPTIONS = Symbol('OPTIONS');

libs/json-api/json-api-nestjs/src/lib/modules/atomic-operation/service/execute.service.ts

@@ -12,14 +12,15 @@ import {
 } from '@nestjs/common/constants';
 import { Module } from '@nestjs/core/injector/module';
 import { ArgumentMetadata } from '@nestjs/common/interfaces/features/pipe-transform.interface';
-import { ModuleRef } from '@nestjs/core';
+import { ApplicationConfig, ModuleRef, NestContainer } from '@nestjs/core';
 import { DataSource } from 'typeorm';
 
-import { ParamsForExecute } from '../types';
+import { MapControllerInterceptor, ParamsForExecute } from '../types';
 import { CURRENT_DATA_SOURCE_TOKEN } from '../../../constants';
 import {
   ASYNC_ITERATOR_FACTORY,
   KEY_MAIN_INPUT_SCHEMA,
+  MAP_CONTROLLER_INTERCEPTORS,
   OPTIONS,
 } from '../constants';
 import { IterateFactory } from '../factory';
@@ -31,6 +32,13 @@ import {
   ValidateQueryError,
 } from '../../../types';
 import { ObjectTyped } from '../../../helper';
+import {
+  InterceptorsConsumer,
+  InterceptorsContextCreator,
+} from '@nestjs/core/interceptors';
+import { Controller } from '@nestjs/common/interfaces';
+import { lastValueFrom } from 'rxjs';
+import { AsyncLocalStorage } from 'async_hooks';
 
 export function isZodError(
   param: string | unknown
@@ -46,11 +54,34 @@ export function isZodError(
 @Injectable()
 export class ExecuteService {
   @Inject(CURRENT_DATA_SOURCE_TOKEN) private readonly dataSource!: DataSource;
-  @Inject(ModuleRef) private readonly moduleRef!: ModuleRef;
+  @Inject(ModuleRef) private readonly moduleRef!: ModuleRef & {
+    container: NestContainer;
+    applicationConfig: ApplicationConfig;
+    _moduleKey: string;
+  };
   @Inject(ASYNC_ITERATOR_FACTORY) private asyncIteratorFactory!: IterateFactory<
     ExecuteService['runOneOperation']
   >;
   @Inject(OPTIONS) private options!: ConfigParam;
+  @Inject(MAP_CONTROLLER_INTERCEPTORS)
+  private mapControllerInterceptor!: MapControllerInterceptor;
+
+  @Inject(AsyncLocalStorage) private asyncLocalStorage!: AsyncLocalStorage<any>;
+
+  private _interceptorsContextCreator!: InterceptorsContextCreator;
+
+  get interceptorsContextCreator() {
+    if (!this._interceptorsContextCreator) {
+      this._interceptorsContextCreator = new InterceptorsContextCreator(
+        this.moduleRef.container,
+        this.moduleRef.applicationConfig
+      );
+    }
+
+    return this._interceptorsContextCreator;
+  }
+
+  private interceptorsConsumer = new InterceptorsConsumer();
 
   async run(params: ParamsForExecute[], tmpIds: (string | number)[]) {
     if (
@@ -79,7 +110,7 @@ export class ExecuteService {
 
   private async executeOperations(
     params: ParamsForExecute[],
-    tmpIds: (string | number)[]
+    tmpIds: (string | number)[] = []
   ) {
     const iterateParams = this.asyncIteratorFactory.createIterator(
       params as Parameters<ExecuteService['runOneOperation']>,
@@ -101,9 +132,39 @@ export class ExecuteService {
         const paramsForExecute = item as unknown as ParamsForExecute['params'];
 
         const itemReplace = this.replaceTmpIds(paramsForExecute, tmpIdsMap);
+        const body = itemReplace.at(-1);
+        const currentTmpId = tmpIds[i];
+
+        if (methodName === 'postOne' && currentTmpId && body) {
+          if (typeof body === 'object' && 'attributes' in body) {
+            body['id'] = `${currentTmpId}`;
+            itemReplace[itemReplace.length - 1];
+          }
+        }
 
-        // @ts-ignore
-        const result = await controller[methodName](...itemReplace);
+        const interceptors = this.getInterceptorsArray(
+          controller,
+          controller[methodName],
+          currentParams.module
+        );
+
+        const result$: any = await this.interceptorsConsumer.intercept(
+          interceptors,
+          [
+            ...Object.values(this.asyncLocalStorage.getStore() || {}),
+            itemReplace,
+          ],
+          controller,
+          // @ts-ignore
+          controller[methodName],
+          // @ts-ignore
+          async () => controller[methodName](...itemReplace)
+        );
+
+        const result =
+          interceptors.length === 0
+            ? await result$
+            : await lastValueFrom(result$);
 
         if (tmpIds[i] && result && !Array.isArray(result.data) && result.data) {
           tmpIdsMap[tmpIds[i]] = result.data.id;
@@ -120,6 +181,41 @@ export class ExecuteService {
     return resultArray;
   }
 
+  private getInterceptorsArray(
+    controller: Controller,
+    callback: (...arg: any) => any,
+    module: ParamsForExecute['module']
+  ) {
+    let controllerFromMap = this.mapControllerInterceptor.get(controller);
+
+    if (!controllerFromMap) {
+      controllerFromMap = new Map();
+      this.mapControllerInterceptor.set(controller, controllerFromMap);
+    }
+
+    const interceptorsFromMap = controllerFromMap.get(callback);
+
+    if (interceptorsFromMap) {
+      return interceptorsFromMap;
+    }
+
+    const interceptorsForController = this.interceptorsContextCreator.create(
+      controller,
+      callback,
+      module.token
+    );
+
+    const interceptorsForMethode = new Set(
+      Reflect.getMetadata(INTERCEPTORS_METADATA, callback) || []
+    );
+
+    const resultInterceptors = interceptorsForController.filter((i) =>
+      interceptorsForMethode.has(i.constructor)
+    );
+    controllerFromMap.set(callback, resultInterceptors);
+    return resultInterceptors;
+  }
+
   private replaceTmpIds<T extends ParamsForExecute['params']>(
     inputParams: T,
     tmpIdsMap: Record<string | number, string | number>
@@ -162,6 +258,7 @@ export class ExecuteService {
         }
         return acum;
       },
+      // @ts-ignore
       { ...relationships }
     );
 

libs/json-api/json-api-nestjs/src/lib/modules/atomic-operation/service/explorer.service.spec.ts

@@ -1,6 +1,11 @@
 import { Test } from '@nestjs/testing';
 import { ModulesContainer } from '@nestjs/core';
-import { MAP_ENTITY, MAP_CONTROLLER_ENTITY } from '../constants';
+import {
+  MAP_ENTITY,
+  MAP_CONTROLLER_ENTITY,
+  OPTIONS,
+  MAP_CONTROLLER_INTERCEPTORS,
+} from '../constants';
 import { Operation } from '../utils';
 import { ExplorerService } from './explorer.service';
 
@@ -31,6 +36,14 @@ describe('ExplorerService', () => {
           provide: MAP_CONTROLLER_ENTITY,
           useValue: new Map([[EntityName, ControllerName]]),
         },
+        {
+          provide: MAP_CONTROLLER_INTERCEPTORS,
+          useValue: new Map(),
+        },
+        {
+          provide: OPTIONS,
+          useValue: {},
+        },
       ],
     }).compile();
 

libs/json-api/json-api-nestjs/src/lib/modules/atomic-operation/types/index.ts

@@ -1,9 +1,14 @@
-import { Type } from '@nestjs/common';
+import { NestInterceptor, Type } from '@nestjs/common';
 import { Module } from '@nestjs/core/injector/module';
+import { Controller } from '@nestjs/common/interfaces';
 import { EntityClassOrSchema } from '@nestjs/typeorm/dist/interfaces/entity-class-or-schema.type';
 import { Entity, MethodName } from '../../../types';
 import { JsonBaseController } from '../../../mixin/controller/json-base.controller';
 
+export type MapControllerInterceptor = Map<
+  Controller,
+  Map<(...arg: any) => any, NestInterceptor[]>
+>;
 export type MapController = Map<EntityClassOrSchema, Type<any>>;
 export type MapEntity = Map<string, EntityClassOrSchema>;