Ajouter la méthode upsert dans le contrôleur IdentitiesController et la méthode upsert dans le service AbstractServiceSchema.

Author: RICHARD-Quentin

Makefile

@@ -3,7 +3,6 @@ APP_PORT = 4002
 IMG_NAME = "ghcr.io/libertech-fr/sesame-orchestrator"
 BASE_NAME = "sesame"
 APP_NAME = "sesame-orchestrator"
-PLATFORM = "linux/amd64"
 
 .DEFAULT_GOAL := help
 help:
@@ -20,7 +19,6 @@ dev: ## Start development environment
 		-e NODE_TLS_REJECT_UNAUTHORIZED=0 \
 		--add-host host.docker.internal:host-gateway \
 		--network dev \
-		--platform $(PLATFORM) \
 		--name $(APP_NAME) \
 		-p $(APP_PORT):4000 \
 		-v $(CURDIR):/data \
@@ -61,9 +59,9 @@ dbs: ## Start databases
 		--health-timeout=3s \
 		--health-start-period=5s \
 		--health-retries=3 \
-		--health-cmd="mongo --eval \"db.stats().ok\" || exit 1" \
-		mongo:7.0 --replSet rs0 --wiredTigerCacheSizeGB 1.5 || true
-	@docker volume create $(APP_NAME)-redis
+		--health-cmd="mongosh --eval \"db.stats().ok\" || exit 1" \
+		mongo:7.0 --replSet rs0 --wiredTigerCacheSizeGB 1.5 --bind_ip localhost,$(BASE_NAME)-mongodb || true
+	@docker volume create $(BASE_NAME)-redis
 	@docker run -d --rm \
 		--name $(BASE_NAME)-redis \
 		-v $(BASE_NAME)-redis:/data \
@@ -76,13 +74,18 @@ dbs: ## Start databases
 		--health-retries=3 \
 		--health-cmd="redis-cli ping || exit 1" \
 		redis || true
-	@docker exec -it $(BASE_NAME)-mongodb mongo --eval "rs.initiate({_id: 'rs0', members: [{_id: 0, host: '127.0.0.1:27017'}]})" || true
+	@docker exec -it $(BASE_NAME)-mongodb mongosh --eval "rs.initiate({_id: 'rs0', members: [{_id: 0, host: '127.0.0.1:27017'}]})" || true
 
 stop: ## Stop the container
 	@docker stop $(APP_NAME) || true
 	@docker stop $(BASE_NAME)-mongodb || true
 	@docker stop $(BASE_NAME)-redis || true
 
+stop-dbs: ## Stop databases
+	@docker stop $(BASE_NAME)-mongodb || true
+	@docker stop $(BASE_NAME)-redis || true
+
+
 run-test: ## Run tests
 	act --container-architecture="linux/arm64" -j test
 

src/_common/abstracts/abstract.service.schema.ts

@@ -1,5 +1,4 @@
 import { Injectable, NotFoundException } from '@nestjs/common';
-import { AbstractSchema } from './schemas/abstract.schema';
 import {
   Document,
   FilterQuery,
@@ -12,9 +11,10 @@ import {
   Types,
   UpdateQuery,
 } from 'mongoose';
+import { EventEmitterSeparator } from '~/_common/constants/event-emitter.constant';
 import { AbstractService, AbstractServiceContext } from './abstract.service';
 import { ServiceSchemaInterface } from './interfaces/service.schema.interface';
-import { EventEmitterSeparator } from '~/_common/constants/event-emitter.constant';
+import { AbstractSchema } from './schemas/abstract.schema';
 
 @Injectable()
 export abstract class AbstractServiceSchema extends AbstractService implements ServiceSchemaInterface {
@@ -191,7 +191,7 @@ export abstract class AbstractServiceSchema extends AbstractService implements S
   public async update<T extends AbstractSchema | Document>(
     _id: Types.ObjectId | any,
     update: UpdateQuery<T>,
-    options?: QueryOptions<T> & { rawResult: true },
+    options?: QueryOptions<T>,
   ): Promise<ModifyResult<Query<T, T, any, T>>> {
     const logInfos = Object.values({
       ...arguments,
@@ -243,7 +243,65 @@ export abstract class AbstractServiceSchema extends AbstractService implements S
       }
     }
     return updated
+  }    
+
+  public async upsert<T extends AbstractSchema | Document>(
+  filter: FilterQuery<T>,
+  update: UpdateQuery<T>,
+  options?: QueryOptions<T>
+  ): Promise<ModifyResult<Query<T, T, any, T>>> {
+    this.logger.debug(['upsert', JSON.stringify(Object.values(arguments))].join(' '));
+    if (this.eventEmitter) {
+      const beforeEvents = await this.eventEmitter?.emitAsync(
+        [this.moduleName.toLowerCase(), this.serviceName.toLowerCase(), 'service', 'beforeUpsert'].join(EventEmitterSeparator),
+        { filter, update, options },
+      );
+      for (const beforeEvent of beforeEvents) {
+        if (beforeEvent?.stop) throw beforeEvent?.stop;
+        if (beforeEvent?.filter) filter = { ...filter, ...beforeEvent.filter };
+        if (beforeEvent?.update) update = { ...update, ...beforeEvent.update };
+        if (beforeEvent?.options) options = { ...options, ...beforeEvent.options };
+      }
+    }
+    const validation = await this._model.validate(update)
+    console.log('validation', validation)
+    let result = await this._model
+      .findOneAndUpdate<Query<T | null, T, any, T>>(
+        filter,
+        {
+          ...update,
+          $set: {
+            ...(update?.$set || {}),
+            'metadata.lastUpdatedBy': this.request?.user?.username || 'anonymous',
+            'metadata.lastUpdatedAt': new Date(),
+          }
+        },
+        {
+          upsert: true,
+          new: true,
+          runValidators: true,
+          ...options,
+        } as QueryOptions<T> & { includeResultMetadata: true },
+      )
+      .exec();
+
+    if (this.eventEmitter) {
+      const afterEvents = await this.eventEmitter?.emitAsync(
+        [this.moduleName.toLowerCase(), this.serviceName.toLowerCase(), 'service', 'afterUpsert'].join(EventEmitterSeparator),
+        { result },
+      );
+      for (const afterEvent of afterEvents) {
+        if (afterEvent?.result) result = { ...result, ...afterEvent.result };
+      }
+    }
+
+    if (!result) {
+      throw new NotFoundException();
+    }
+
+    return result;
   }
+  
 
   public async delete<T extends AbstractSchema | Document>(_id: Types.ObjectId | any, options?: QueryOptions<T> | null | undefined): Promise<Query<T, T, any, T>> {
     this.logger.debug(['delete', JSON.stringify(Object.values(arguments))].join(' '))

src/management/identities/identities.controller.ts

@@ -81,6 +81,40 @@ export class IdentitiesController extends AbstractController {
     });
   }
 
+  @Post('upsert')
+  @ApiCreateDecorator(IdentitiesCreateDto, IdentitiesDto)
+  public async upsert(
+    @Res()
+    res: Response,
+    @Body() body: IdentitiesCreateDto,
+  ): Promise<
+    Response<
+      {
+        statusCode: number;
+        data?: Document<Identities, any, Identities>;
+        message?: string;
+        validations?: MixedValue;
+      },
+      any
+    >
+  > {
+    let statusCode = HttpStatus.CREATED;
+    let message = null;
+    const data = await this._service.upsert<Identities>(body);
+    // If the state is TO_COMPLETE, the identity is created but additional fields are missing or invalid
+    // Else the state is TO_VALIDATE, we return a 201 status code
+    if ((data as unknown as Identities).state === IdentityState.TO_COMPLETE) {
+      statusCode = HttpStatus.ACCEPTED;
+      message = 'Identitée créée avec succès, mais des champs additionnels sont manquants ou invalides.';
+    }
+
+    return res.status(statusCode).json({
+      statusCode,
+      data,
+      message,
+    });
+  }
+
   @Get()
   @ApiPaginatedDecorator(PickProjectionHelper(IdentitiesDto, IdentitiesController.projection))
   public async search(

src/management/identities/identities.service.ts

@@ -1,24 +1,48 @@
-import { Injectable } from '@nestjs/common';
+import { additionalFieldsPartDto } from './_dto/_parts/additionalFields.dto';
+import { HttpException, Injectable, Logger } from '@nestjs/common';
 import { InjectModel } from '@nestjs/mongoose';
 import { Identities } from './_schemas/identities.schema';
 import { Document, Model, ModifyResult, Query, QueryOptions, SaveOptions, Types, UpdateQuery } from 'mongoose';
 import { AbstractServiceSchema } from '~/_common/abstracts/abstract.service.schema';
 import { AbstractSchema } from '~/_common/abstracts/schemas/abstract.schema';
+import { IdentitiesValidationService } from './validations/identities.validation.service';
+import { ValidationConfigException, ValidationSchemaException } from '~/_common/errors/ValidationException';
+import { IdentityState } from './_enums/states.enum';
 
 @Injectable()
 export class IdentitiesService extends AbstractServiceSchema {
-  constructor(@InjectModel(Identities.name) protected _model: Model<Identities>) {
+  constructor(
+    @InjectModel(Identities.name) protected _model: Model<Identities>,
+    protected readonly _validation: IdentitiesValidationService,
+  ) {
     super();
   }
 
   public async create<T extends AbstractSchema | Document>(
     data?: any,
     options?: SaveOptions,
   ): Promise<Document<T, any, T>> {
-    // noinspection UnnecessaryLocalVariableJS
     const created: Document<T, any, T> = await super.create(data, options);
-    //TODO: add backends service logic here (TO_SYNC)
     return created;
+    //TODO: add backends service logic here
+  }
+
+  public async upsert<T extends AbstractSchema | Document>(
+    data?: any,
+    options?: QueryOptions<T>,
+  ): Promise<ModifyResult<Query<T, T, any, T>>> {
+    const logPrefix = `Validation [${data.inetOrgPerson.cn}]:`;
+    try {
+      Logger.log(`${logPrefix} Starting additionalFields validation.`);
+      await this._validation.validate(data.additionalFields);
+      Logger.log(`${logPrefix} AdditionalFields validation successful.`);
+      data.state = IdentityState.TO_VALIDATE;
+    } catch (error) {
+      data = this.handleValidationError(error, data, logPrefix);
+    }
+    const upsert = await super.upsert({ 'inetOrgPerson.uid': data.inetOrgPerson.uid }, data, options);
+    return upsert;
+    //TODO: add backends service logic here
   }
 
   public async update<T extends AbstractSchema | Document>(
@@ -42,4 +66,27 @@ export class IdentitiesService extends AbstractServiceSchema {
     //TODO: add backends service logic here (TO_SYNC)
     return deleted;
   }
+
+  private handleValidationError(error: Error | HttpException, identity: Identities, logPrefix: string) {
+    if (error instanceof ValidationConfigException) {
+      Logger.error(`${logPrefix} Validation config error. ${JSON.stringify(error.getValidations())}`);
+      throw new ValidationConfigException(error.getPayload());
+    }
+
+    if (error instanceof ValidationSchemaException) {
+      Logger.warn(`${logPrefix} Validation schema error. ${JSON.stringify(error.getValidations())}`);
+      if (identity.state === IdentityState.TO_CREATE) {
+        Logger.warn(`${logPrefix} State set to TO_COMPLETE.`);
+        identity.state = IdentityState.TO_COMPLETE;
+        identity.additionalFields.validations = error.getValidations();
+        return identity;
+      } else {
+        Logger.error(`${logPrefix} Validation schema error. ${JSON.stringify(error.getValidations())}`);
+        throw new ValidationSchemaException(error.getPayload());
+      }
+    } else {
+      Logger.error(`${logPrefix} Unhandled error: ${error.message}`);
+      throw error; // Rethrow the original error if it's not one of the handled types.
+    }
+  }
 }