Unsubscribe from Ongoing Merchant Monitoring (#2799)

* feat: unsubscribe from ongoing merchant monitoring

* feat: finished patch business by id endpoint

* feat: pr comments fixes

Author: tomer-shvadron

services/workflows-service/prisma/data-migrations

@@ -2,10 +2,10 @@ import { ApiNestedQuery } from '@/common/decorators/api-nested-query.decorator';
 import * as common from '@nestjs/common';
 import { Param } from '@nestjs/common';
 import * as swagger from '@nestjs/swagger';
+import { ApiBearerAuth, ApiExcludeEndpoint } from '@nestjs/swagger';
 import { plainToClass } from 'class-transformer';
 import type { Request } from 'express';
 import * as errors from '../errors';
-// import * as nestAccessControl from 'nest-access-control';
 import { BusinessFindManyArgs } from './dtos/business-find-many-args';
 import { BusinessWhereUniqueInput } from './dtos/business-where-unique-input';
 import { BusinessModel } from './business.model';
@@ -23,13 +23,19 @@ import { UseCustomerAuthGuard } from '@/common/decorators/use-customer-auth-guar
 import { ProjectIds } from '@/common/decorators/project-ids.decorator';
 import type { TProjectId, TProjectIds } from '@/types';
 import { CurrentProject } from '@/common/decorators/current-project.decorator';
+import { BusinessPatchDto } from '@/business/dtos/business.patch.dto';
+import { BusinessDto } from '@/business/dtos/business.dto';
+import { PrismaService } from '@/prisma/prisma.service';
+import { ARRAY_MERGE_OPTION } from '@ballerine/workflow-core';
 
+@ApiBearerAuth()
 @swagger.ApiTags('Businesses')
 @common.Controller('external/businesses')
 export class BusinessControllerExternal {
   constructor(
-    protected readonly service: BusinessService,
-    protected readonly workflowService: WorkflowService, // @nestAccessControl.InjectRolesBuilder() // protected readonly rolesBuilder: nestAccessControl.RolesBuilder,
+    protected readonly prismaService: PrismaService,
+    protected readonly businessService: BusinessService,
+    protected readonly workflowService: WorkflowService,
   ) {}
 
   @common.Post()
@@ -40,7 +46,7 @@ export class BusinessControllerExternal {
     @common.Body() data: BusinessCreateDto,
     @CurrentProject() currentProjectId: TProjectId,
   ): Promise<Pick<BusinessModel, 'id' | 'companyName'>> {
-    return this.service.create({
+    return this.businessService.create({
       data: {
         ...data,
         legalForm: 'name',
@@ -67,15 +73,15 @@ export class BusinessControllerExternal {
   ): Promise<BusinessModel[]> {
     const args = plainToClass(BusinessFindManyArgs, request.query);
 
-    return this.service.list(args, projectIds);
+    return this.businessService.list(args, projectIds);
   }
 
   @UseKeyAuthOrSessionGuard()
   @common.Get('/business-information')
   async getCompanyInfo(@common.Query() query: BusinessInformation) {
     const { jurisdictionCode, vendor, registrationNumber } = query;
 
-    return this.service.fetchCompanyInformation({
+    return this.businessService.fetchCompanyInformation({
       registrationNumber,
       jurisdictionCode,
       vendor,
@@ -92,9 +98,7 @@ export class BusinessControllerExternal {
     @ProjectIds() projectIds: TProjectIds,
   ): Promise<BusinessModel | null> {
     try {
-      const business = await this.service.getById(params.id, {}, projectIds);
-
-      return business;
+      return await this.businessService.getById(params.id, {}, projectIds);
     } catch (err) {
       if (isRecordNotFoundError(err)) {
         throw new errors.NotFoundException(`No resource was found for ${JSON.stringify(params)}`);
@@ -105,13 +109,14 @@ export class BusinessControllerExternal {
   }
 
   @common.Put(':id')
+  @ApiExcludeEndpoint()
   @UseCustomerAuthGuard()
   async update(
     @common.Param('id') businessId: string,
     @common.Body() data: BusinessUpdateDto,
     @CurrentProject() currentProjectId: TProjectId,
   ) {
-    return this.service.updateById(businessId, {
+    return this.businessService.updateById(businessId, {
       data: {
         companyName: data.companyName,
         address: data.address,
@@ -127,6 +132,75 @@ export class BusinessControllerExternal {
     });
   }
 
+  @common.Patch(':id')
+  @UseCustomerAuthGuard()
+  @swagger.ApiForbiddenResponse()
+  @swagger.ApiOkResponse({ type: BusinessDto })
+  @swagger.ApiNotFoundResponse({ type: errors.NotFoundException })
+  async patch(
+    @common.Param('id') businessId: string,
+    @common.Body() data: BusinessPatchDto,
+    @CurrentProject() currentProjectId: TProjectId,
+  ) {
+    const {
+      documents,
+      shareholderStructure,
+      additionalInfo,
+      bankInformation,
+      address,
+      metadata,
+      ...restOfData
+    } = data;
+
+    return await this.prismaService.$transaction(async transaction => {
+      try {
+        // Validating the business exists
+        await this.businessService.getById(businessId, { select: { metadata: true } }, [
+          currentProjectId,
+        ]);
+
+        if (metadata) {
+          const stringifiedMetadata = JSON.stringify(metadata);
+
+          await transaction.$executeRaw`
+              UPDATE "Business"
+              SET "metadata" = jsonb_deep_merge_with_options(
+                COALESCE("metadata", '{}'::jsonb),
+                ${stringifiedMetadata}::jsonb,
+                ${ARRAY_MERGE_OPTION.BY_INDEX}
+              )
+              WHERE "id" = ${businessId} AND "projectId" = ${currentProjectId};
+            `;
+        }
+
+        return this.businessService.updateById(
+          businessId,
+          {
+            data: {
+              ...restOfData,
+              documents: documents ? JSON.stringify(documents) : undefined,
+              additionalInfo: additionalInfo ? JSON.stringify(additionalInfo) : undefined,
+              bankInformation: bankInformation ? JSON.stringify(bankInformation) : undefined,
+              address: address ? JSON.stringify(address) : undefined,
+              shareholderStructure:
+                shareholderStructure && shareholderStructure.length
+                  ? JSON.stringify(shareholderStructure)
+                  : undefined,
+              projectId: currentProjectId,
+            },
+          },
+          transaction,
+        );
+      } catch (error) {
+        if (isRecordNotFoundError(error)) {
+          throw new errors.NotFoundException(`No business was found for id "${businessId}"`);
+        }
+
+        throw error;
+      }
+    });
+  }
+
   // curl -v http://localhost:3000/api/v1/external/businesses/:businessId/workflows
   @common.Get('/:businessId/workflows')
   @swagger.ApiOkResponse({ type: [WorkflowDefinitionModel] })

services/workflows-service/src/business/business.controller.external.ts

@@ -11,13 +11,13 @@ import { ValidationError } from '@/errors';
 @Injectable()
 export class BusinessRepository {
   constructor(
-    protected readonly prisma: PrismaService,
+    protected readonly prismaService: PrismaService,
     protected readonly scopeService: ProjectScopeService,
   ) {}
 
   async create<T extends Prisma.BusinessCreateArgs>(
     args: Prisma.SelectSubset<T, Prisma.BusinessCreateArgs>,
-    transaction: PrismaClient | PrismaTransaction = this.prisma,
+    transaction: PrismaClient | PrismaTransaction = this.prismaService,
   ) {
     const result = BusinessCreateInputSchema.safeParse(args.data);
 
@@ -35,15 +35,17 @@ export class BusinessRepository {
     args: Prisma.SelectSubset<T, Prisma.BusinessFindManyArgs>,
     projectIds: TProjectIds,
   ) {
-    return await this.prisma.business.findMany(this.scopeService.scopeFindMany(args, projectIds));
+    return await this.prismaService.business.findMany(
+      this.scopeService.scopeFindMany(args, projectIds),
+    );
   }
 
   async findById<T extends Omit<Prisma.BusinessFindFirstOrThrowArgs, 'where'>>(
     id: string,
     args: Prisma.SelectSubset<T, Omit<Prisma.BusinessFindFirstOrThrowArgs, 'where'>>,
     projectIds: TProjectIds,
   ) {
-    return await this.prisma.business.findFirstOrThrow(
+    return await this.prismaService.business.findFirstOrThrow(
       this.scopeService.scopeFindFirst(
         {
           where: { id },
@@ -58,7 +60,7 @@ export class BusinessRepository {
     id: string,
     args: Prisma.SelectSubset<T, Omit<Prisma.BusinessFindUniqueOrThrowArgs, 'where'>>,
   ) {
-    return await this.prisma.business.findUniqueOrThrow({
+    return await this.prismaService.business.findUniqueOrThrow({
       where: { id },
       ...args,
     });
@@ -69,7 +71,7 @@ export class BusinessRepository {
     projectIds: TProjectIds,
     args?: Prisma.SelectSubset<T, Omit<Prisma.BusinessFindFirstArgs, 'where'>>,
   ) {
-    return await this.prisma.business.findFirst(
+    return await this.prismaService.business.findFirst(
       this.scopeService.scopeFindFirst(
         {
           where: { correlationId: id },
@@ -82,7 +84,7 @@ export class BusinessRepository {
 
   async getCorrelationIdById(id: string, projectIds: TProjectIds): Promise<string | null> {
     return (
-      await this.prisma.business.findFirstOrThrow(
+      await this.prismaService.business.findFirstOrThrow(
         this.scopeService.scopeFindFirst(
           {
             where: { id },
@@ -97,7 +99,7 @@ export class BusinessRepository {
   async updateById<T extends Omit<Prisma.BusinessUpdateArgs, 'where'>>(
     id: string,
     args: Prisma.SelectSubset<T, Omit<Prisma.BusinessUpdateArgs, 'where'>>,
-    transaction: PrismaClient | PrismaTransaction = this.prisma,
+    transaction: PrismaClient | PrismaTransaction = this.prismaService,
   ): Promise<BusinessModel> {
     return await transaction.business.update({
       where: { id },

services/workflows-service/src/business/business.repository.ts

@@ -58,8 +58,12 @@ export class BusinessService {
     return await this.repository.findByCorrelationId(correlationId, projectids, args);
   }
 
-  async updateById(id: string, args: Parameters<BusinessRepository['updateById']>[1]) {
-    return await this.repository.updateById(id, args);
+  async updateById(
+    id: string,
+    args: Parameters<BusinessRepository['updateById']>[1],
+    transaction?: PrismaTransaction,
+  ) {
+    return await this.repository.updateById(id, args, transaction);
   }
 
   async fetchCompanyInformation({

services/workflows-service/src/business/business.service.ts

@@ -0,0 +1,28 @@
+import { IsDate, IsString } from 'class-validator';
+import { ApiProperty } from '@nestjs/swagger';
+import { BusinessPatchDto } from './business.patch.dto';
+import { Type } from 'class-transformer';
+
+export class BusinessDto extends BusinessPatchDto {
+  @ApiProperty({ type: String, required: true })
+  @IsString()
+  id!: string;
+
+  @ApiProperty({
+    required: true,
+  })
+  @IsDate()
+  @Type(() => Date)
+  createdAt!: Date;
+
+  @ApiProperty({
+    required: true,
+  })
+  @IsDate()
+  @Type(() => Date)
+  updatedAt!: Date;
+
+  @ApiProperty({ type: String, required: true })
+  @IsString()
+  projectId!: string;
+}