@mbc-cqrs-serverless/master 0.1.69-beta.0 → 0.1.71-beta.0

package/src/templates/master/handler/master-sfn-task.handler.ts

@@ -1,332 +0,0 @@
-import {
-  DataModel,
-  DataService,
-  DynamoDbService,
-  EventHandler,
-  extractInvokeContext,
-  IEventHandler,
-  IInvoke,
-  KEY_SEPARATOR,
-} from '@mbc-cqrs-serverless/core'
-import {
-  CopyType,
-  DataCopyMode,
-  DataCopyOptionDto,
-  MasterCopyDto,
-  MasterDataService,
-  MasterSettingService,
-} from '@mbc-cqrs-serverless/master'
-import { RotateByEnum, SequencesService } from '@mbc-cqrs-serverless/sequence'
-import { Logger } from '@nestjs/common'
-import { Prisma } from '@prisma/client'
-import { chunk } from 'lodash'
-import {
-  DATA_SK_PREFIX,
-  DEFAULT_TENANT_CODE,
-  generateMasterPk,
-  genSequenceSk,
-  parseId,
-  sequencePk,
-} from 'src/helpers/id'
-import { PrismaService } from 'src/prisma'
-
-import { MasterSfnTaskEvent } from './master-sfn-task.event'
-
-const BATCH_SIZE = 100
-
-@EventHandler(MasterSfnTaskEvent)
-export class MasterSfnTaskEventHandler
-  implements IEventHandler<MasterSfnTaskEvent>
-{
-  private readonly logger = new Logger(MasterSfnTaskEventHandler.name)
-  private sequenceTableName
-
-  constructor(
-    private readonly dynamoDbService: DynamoDbService,
-
-    private readonly prismaService: PrismaService,
-    private readonly masterSettingService: MasterSettingService,
-    private readonly masterDataService: MasterDataService,
-    private readonly dataService: DataService,
-    private readonly sequencesService: SequencesService,
-  ) {
-    this.sequenceTableName = this.dynamoDbService.getTableName('sequences')
-  }
-
-  async execute(event: MasterSfnTaskEvent): Promise<any> {
-    const invokeContext = extractInvokeContext()
-    const masterCopyDto = event.input?.input as unknown as MasterCopyDto
-
-    this.logger.debug('sfn-event:masterCopyDto:', masterCopyDto)
-
-    const { masterSettingId, targetTenants, copyType, dataCopyOption } =
-      masterCopyDto
-    const targetTenant = `${targetTenants[0]}`
-
-    const setting = await this.fetchSetting(masterSettingId)
-    const masterCode = this.getMasterCodeFromSetting(setting)
-    if (copyType === CopyType.SETTING_ONLY || copyType === CopyType.BOTH) {
-      await this.copySettingToTenant(setting, targetTenant, invokeContext)
-    }
-
-    if (copyType === CopyType.DATA_ONLY || copyType === CopyType.BOTH) {
-      const isCopySequence = await this.shouldCopySequence(
-        setting,
-        targetTenant,
-      )
-      if (isCopySequence) {
-        await this.copySeqToTenant(setting, targetTenant)
-      }
-
-      const dataToCopy = await this.fetchMasterData(masterCode, dataCopyOption)
-
-      await this.copyDataToTenant(dataToCopy, targetTenant, invokeContext)
-    }
-
-    this.logger.debug('Completed copy process for tenant:', targetTenant)
-    return { message: 'Copy successfully', event }
-  }
-
-  private async fetchSetting(id: string) {
-    const setting = await this.dataService.getItem(parseId(id))
-    this.logger.debug('sfn-event-setting', setting)
-    return setting
-  }
-
-  private async fetchMasterData(
-    masterCode: string,
-    dataCopyOption?: DataCopyOptionDto,
-    tenant: string = DEFAULT_TENANT_CODE,
-  ): Promise<Prisma.MasterUncheckedCreateInput[]> {
-    const where: Prisma.MasterWhereInput = {
-      masterType: DATA_SK_PREFIX,
-      masterTypeCode: masterCode,
-      pk: `MASTER${KEY_SEPARATOR}${tenant}`,
-    }
-
-    if (dataCopyOption?.mode === DataCopyMode.PARTIAL) {
-      where.id = { in: dataCopyOption.id }
-    }
-
-    this.logger.debug('sfn-event-whereCondition', where)
-    const data = await this.prismaService.master.findMany({ where })
-    this.logger.debug('sfn-event-dataToCopy', data.length)
-    return data
-  }
-
-  private async copySettingToTenant(
-    setting: DataModel,
-    tenantCode: string,
-    invokeContext: IInvoke,
-  ) {
-    const sk = setting.sk
-    const pk = generateMasterPk(tenantCode)
-    const masterCode = this.getMasterCodeFromSetting(setting)
-
-    const tenantSetting = await this.dataService.getItem({ pk, sk })
-
-    this.logger.debug(
-      'sfn-event-copySettingToTenant-tenantSetting',
-      tenantSetting,
-    )
-
-    if (tenantSetting && tenantSetting.isDeleted === false) {
-      this.logger.debug('sfn-event-copySettingToTenant-updateSetting', {
-        pk,
-        sk,
-      })
-
-      await this.masterSettingService.updateSetting(
-        { pk, sk },
-        {
-          name: setting.name,
-          code: masterCode,
-          settingValue: setting.attributes as object,
-          tenantCode,
-        },
-        {
-          invokeContext,
-        },
-      )
-    } else {
-      this.logger.debug('sfn-event-copySettingToTenant-createTenantSetting', {
-        pk,
-        sk,
-      })
-
-      await this.masterSettingService.createTenantSetting(
-        {
-          name: setting.name,
-          code: masterCode,
-          settingValue: setting.attributes,
-          tenantCode,
-        },
-        { invokeContext },
-      )
-    }
-  }
-
-  private async copyDataToTenant(
-    dataToCopy: Prisma.MasterUncheckedCreateInput[],
-    tenantCode: string,
-    invokeContext: IInvoke,
-  ) {
-    const chunks = chunk(dataToCopy, BATCH_SIZE)
-    for (const batch of chunks) {
-      await Promise.all(
-        batch.map(async (data) => {
-          const parts = data.sk.split(KEY_SEPARATOR)
-          const sk =
-            parts.length > 1 && parts[1].trim() === ''
-              ? `${data.sk}${data.masterCode}`
-              : data.sk
-          const pk = generateMasterPk(tenantCode)
-
-          const tenantData = await this.dataService.getItem({ pk, sk })
-
-          this.logger.debug('sfn-event-copyDataToTenant-tenantData', tenantData)
-
-          // des tenant data is exist and not deleted => update des data same as src data
-          if (tenantData && tenantData.isDeleted === false) {
-            this.logger.debug('sfn-event-copyDataToTenant-update', { pk, sk })
-
-            return this.masterDataService.update(
-              { pk, sk },
-              {
-                name: data.name,
-                attributes: data.attributes as object,
-                isDeleted: data.isDeleted,
-                seq: data.seq,
-              },
-              {
-                invokeContext,
-              },
-            )
-          }
-
-          // src data is deleted => do nothing
-          if (data.isDeleted === true) return
-
-          // src data is exist => create des data
-          return this.masterDataService.create(
-            {
-              code: data.masterCode,
-              tenantCode,
-              name: data.name,
-              settingCode: data.masterTypeCode,
-              attributes: data.attributes as object,
-              seq: data.seq,
-            },
-            { invokeContext },
-          )
-        }),
-      )
-    }
-  }
-
-  private async shouldCopySequence(
-    setting: DataModel,
-    tenantCode: string,
-  ): Promise<boolean> {
-    const fields = setting?.attributes?.['fields'] || []
-    const codeField = fields.find((f) => f.physicalName === 'code')
-    if (codeField?.dataType !== 'auto_number') {
-      this.logger.debug('Sequence not required: code field not auto_number')
-      return false
-    }
-
-    const jcciSeqKey = this.generateSequenceKey(tenantCode, setting)
-    const { seq: jcciSeq = 0 } =
-      (await this.sequencesService.getCurrentSequence(jcciSeqKey)) ?? {}
-    this.logger.debug('sfn-event-shouldCopySequence-jcciSeq', {
-      jcciSeqKey,
-      jcciSeq,
-    })
-
-    if (jcciSeq === 0) {
-      this.logger.debug('Skipping sequence copy: JCCI sequence is 0')
-      return false
-    }
-
-    const tenantSeqKey = this.generateSequenceKey(tenantCode, setting)
-    const { seq: tenantSeq } =
-      (await this.sequencesService.getCurrentSequence(tenantSeqKey)) ?? {}
-    this.logger.debug('sfn-event-shouldCopySequence-tenantSeq', {
-      tenantSeqKey,
-      tenantSeq,
-    })
-
-    if (tenantSeq === undefined || tenantSeq === null) {
-      this.logger.debug('Tenant sequence missing: copying sequence required')
-      return true
-    }
-
-    if (jcciSeq > tenantSeq) {
-      this.logger.debug('Tenant sequence is behind: copying required')
-      return true
-    }
-
-    this.logger.debug('Tenant sequence is up to date or ahead: no copy needed')
-    return false
-  }
-
-  private async copySeqToTenant(setting: DataModel, tenantCode: string) {
-    const fields = setting?.attributes?.['fields'] || []
-    const codeField = fields.find((f) => f.physicalName === 'code')
-    const typeCode = codeField.formatCode ?? codeField.dataFormat
-
-    const jcciSeqKey = this.generateSequenceKey(tenantCode, setting)
-    const { seq: jcciSeq = 0 } =
-      (await this.sequencesService.getCurrentSequence(jcciSeqKey)) ?? {}
-
-    const tenantSeqKey = this.generateSequenceKey(tenantCode, setting)
-    const { seq: tenantSeq = 0 } =
-      (await this.sequencesService.getCurrentSequence(tenantSeqKey)) ?? {}
-
-    const distance = jcciSeq - tenantSeq
-    this.logger.debug('Copying sequence gap:', {
-      jcciSeq,
-      tenantSeq,
-      distance,
-    })
-
-    this.logger.debug('putItem', {
-      pk: tenantSeqKey.pk,
-      sk: tenantSeqKey.sk,
-      code: tenantSeqKey.sk,
-      name: tenantSeqKey.sk.split(KEY_SEPARATOR).at(-1),
-      seq: jcciSeq,
-      tenantCode,
-      type: typeCode,
-    })
-
-    this.logger.debug('this.sequenceTableName', this.sequenceTableName)
-
-    await this.dynamoDbService.putItem(this.sequenceTableName, {
-      pk: tenantSeqKey.pk,
-      sk: tenantSeqKey.sk,
-      code: tenantSeqKey.sk,
-      name: tenantSeqKey.sk.split(KEY_SEPARATOR).at(-1),
-      seq: jcciSeq,
-      tenantCode,
-      type: typeCode,
-    })
-  }
-
-  private generateSequenceKey(tenantCode: string, setting: DataModel) {
-    const fields = setting?.attributes?.['fields'] || []
-    const codeField = fields.find((f) => f.physicalName === 'code')
-    const seqSk = codeField.formatCode ?? codeField.dataFormat
-
-    const pk = sequencePk(tenantCode)
-    const masterCode = this.getMasterCodeFromSetting(setting)
-    const sk = genSequenceSk(seqSk, masterCode, RotateByEnum.NONE)
-
-    return { pk, sk }
-  }
-
-  private getMasterCodeFromSetting(setting: DataModel): string {
-    const parts = setting.sk.split(KEY_SEPARATOR)
-    return parts[1]
-  }
-}

package/src/templates/master/master-setting.controller.ts

@@ -1,23 +0,0 @@
-import { IInvoke, INVOKE_CONTEXT } from '@mbc-cqrs-serverless/core'
-import { MasterCopyDto } from '@mbc-cqrs-serverless/master'
-import { Body, Controller, Injectable, Post } from '@nestjs/common'
-import { ApiTags } from '@nestjs/swagger'
-
-import { CustomMasterSettingService } from './master-setting.service'
-
-@ApiTags('master-setting')
-@Controller('api/master-setting')
-@Injectable()
-export class CustomMasterSettingController {
-  constructor(
-    private readonly masterSettingService: CustomMasterSettingService,
-  ) {}
-
-  @Post('/copy')
-  async copyMaster(
-    @INVOKE_CONTEXT() invokeContext: IInvoke,
-    @Body() masterCopyDto: MasterCopyDto,
-  ): Promise<any> {
-    return this.masterSettingService.copy(masterCopyDto, { invokeContext })
-  }
-}

package/src/templates/master/master-setting.service.ts

@@ -1,55 +0,0 @@
-import { DataService, getUserContext, IInvoke } from '@mbc-cqrs-serverless/core'
-import { DataCopyMode, MasterCopyDto } from '@mbc-cqrs-serverless/master'
-import { TaskService } from '@mbc-cqrs-serverless/task'
-import { BadRequestException, Injectable, Logger } from '@nestjs/common'
-
-import { MASTER_COPY_SK_PREFIX, parseId } from './helpers'
-
-@Injectable()
-export class CustomMasterSettingService {
-  private readonly logger = new Logger(CustomMasterSettingService.name)
-
-  constructor(
-    private readonly dataService: DataService,
-    private readonly taskService: TaskService,
-  ) {}
-
-  async copy(
-    masterCopyDto: MasterCopyDto,
-    opts: { invokeContext: IInvoke },
-  ): Promise<any> {
-    this.logger.debug('cmd:', JSON.stringify(masterCopyDto))
-
-    const userContext = getUserContext(opts.invokeContext)
-
-    const { masterSettingId, targetTenants, dataCopyOption } = masterCopyDto
-
-    if (dataCopyOption?.mode === DataCopyMode.PARTIAL) {
-      if (!dataCopyOption.id?.length) {
-        throw new BadRequestException('Must provide ID when mode is PARTIAL.')
-      }
-    }
-
-    const setting = await this.dataService.getItem(parseId(masterSettingId))
-
-    if (!setting || setting.isDeleted) {
-      throw new BadRequestException('Master setting does not exist')
-    }
-
-    const item = targetTenants.map((tenant) => ({
-      ...masterCopyDto,
-      targetTenants: [tenant],
-    }))
-
-    const taskItem = await this.taskService.createStepFunctionTask(
-      {
-        input: item,
-        taskType: `${MASTER_COPY_SK_PREFIX}_${masterSettingId.split('#').at(-1)}`,
-        tenantCode: userContext.tenantCode,
-      },
-      opts,
-    )
-
-    return taskItem
-  }
-}