@mbc-cqrs-serverless/master 0.1.66-beta.0 → 0.1.68-beta.0

package/src/templates/master/dto/master-data-update.dto.ts

@@ -0,0 +1,25 @@
+import {
+  IsBoolean,
+  IsNumber,
+  IsObject,
+  IsOptional,
+  IsString,
+} from 'class-validator'
+
+export class MasterDataUpdateDto {
+  @IsString()
+  @IsOptional()
+  name?: string
+
+  @IsBoolean()
+  @IsOptional()
+  isDeleted?: boolean
+
+  @IsNumber()
+  @IsOptional()
+  seq?: number
+
+  @IsObject()
+  @IsOptional()
+  attributes?: object
+}

package/src/templates/master/dto/master-rds-list.entity.ts

@@ -0,0 +1,15 @@
+import { ApiProperty } from '@nestjs/swagger'
+
+import { MasterRdsEntity } from './master-rds.entity'
+
+export class MasterRdsListEntity {
+  @ApiProperty({ type: Number })
+  total?: number
+
+  @ApiProperty({ type: MasterRdsEntity, isArray: true })
+  items: MasterRdsEntity[]
+
+  constructor(data: Partial<MasterRdsListEntity>) {
+    Object.assign(this, data)
+  }
+}

package/src/templates/master/dto/master-rds.entity.ts

@@ -0,0 +1,77 @@
+import { ApiProperty } from '@nestjs/swagger'
+import { Master } from '@prisma/client'
+
+export class MasterRdsEntity {
+  @ApiProperty()
+  id: string
+
+  @ApiProperty()
+  cpk: string
+
+  @ApiProperty()
+  csk: string
+
+  @ApiProperty()
+  pk: string
+
+  @ApiProperty()
+  sk: string
+
+  @ApiProperty()
+  masterType: string
+
+  @ApiProperty()
+  masterTypeCode: string
+
+  @ApiProperty()
+  masterCode: string
+
+  @ApiProperty()
+  tenantCode: string
+
+  @ApiProperty()
+  seq: number
+
+  @ApiProperty()
+  code: string
+
+  @ApiProperty()
+  name: string
+
+  @ApiProperty()
+  version: number
+
+  @ApiProperty()
+  isDeleted: boolean
+
+  @ApiProperty()
+  createdBy: string
+
+  @ApiProperty()
+  createdIp: string
+
+  @ApiProperty()
+  createdAt: Date
+
+  @ApiProperty()
+  updatedBy: string
+
+  @ApiProperty()
+  updatedIp: string
+
+  @ApiProperty()
+  updatedAt: Date
+
+  @ApiProperty({ required: false })
+  syncFrom?: string
+
+  @ApiProperty({ required: false })
+  syncDate?: Date
+
+  @ApiProperty({ type: 'object', required: false })
+  attributes?: Record<string, any>
+
+  constructor(data: Partial<Master>) {
+    Object.assign(this, data)
+  }
+}

package/src/templates/master/dto/master-setting-search.dto.ts

@@ -0,0 +1,20 @@
+import { SearchDto } from '@mbc-cqrs-serverless/core'
+import { Transform } from 'class-transformer'
+import { IsBoolean, IsOptional, IsString } from 'class-validator'
+
+export class MasterSettingSearchDto extends SearchDto {
+  @IsOptional()
+  @IsString()
+  code?: string
+
+  @IsOptional()
+  @IsString()
+  name?: string
+
+  @IsBoolean()
+  @Transform(({ value }) =>
+    value === 'true' ? true : value === 'false' ? false : value,
+  )
+  @IsOptional()
+  isDeleted?: boolean
+}

package/src/templates/master/dto/master-setting-update.dto.ts

@@ -0,0 +1,11 @@
+import { IsObject, IsOptional, IsString } from 'class-validator'
+
+export class MasterSettingUpdateDto {
+  @IsString()
+  @IsOptional()
+  name?: string
+
+  @IsObject()
+  @IsOptional()
+  attributes?: object
+}

package/src/templates/master/entity/master-command.entity.ts

@@ -0,0 +1,11 @@
+import { CommandEntity } from '@mbc-cqrs-serverless/core'
+
+export class MasterCommandEntity extends CommandEntity {
+  attributes: Record<string, any>
+
+  constructor(partial: Partial<MasterCommandEntity>) {
+    super()
+
+    Object.assign(this, partial)
+  }
+}

package/src/templates/master/entity/master-data-list.entity.ts

@@ -0,0 +1,13 @@
+import { DataListEntity } from '@mbc-cqrs-serverless/core'
+
+import { MasterDataEntity } from './master-data.entity'
+
+export class MasterDataListEntity extends DataListEntity {
+  items: MasterDataEntity[]
+
+  constructor(partial: Partial<MasterDataListEntity>) {
+    super(partial)
+
+    Object.assign(this, partial)
+  }
+}

package/src/templates/master/entity/master-data.entity.ts

@@ -0,0 +1,11 @@
+import { DataEntity } from '@mbc-cqrs-serverless/core'
+
+export class MasterDataEntity extends DataEntity {
+  attributes: Record<string, any>
+
+  constructor(partial: Partial<MasterDataEntity>) {
+    super(partial)
+
+    Object.assign(this, partial)
+  }
+}

package/src/templates/master/handler/master-rds.handler.ts

@@ -0,0 +1,75 @@
+import {
+  CommandModel,
+  IDataSyncHandler,
+  KEY_SEPARATOR,
+  removeSortKeyVersion,
+} from '@mbc-cqrs-serverless/core'
+import { Injectable, Logger } from '@nestjs/common'
+import { DATA_SK_PREFIX, SETTING_SK_PREFIX } from 'src/helpers/id'
+import { PrismaService } from 'src/prisma'
+
+import { MasterCommandEntity } from '../entity/master-command.entity'
+
+@Injectable()
+export class MasterDataSyncRdsHandler implements IDataSyncHandler {
+  private readonly logger = new Logger(MasterDataSyncRdsHandler.name)
+
+  constructor(private readonly prismaService: PrismaService) {}
+  // MASTER#9999
+  // MASTER_SETTING#ABC
+
+  // MASTER#9999
+  // ABC#1
+  async up(cmd: MasterCommandEntity): Promise<any> {
+    const sk = removeSortKeyVersion(cmd.sk)
+    const skSplit = sk.split(KEY_SEPARATOR)
+
+    const masterType =
+      skSplit[0] === SETTING_SK_PREFIX ? SETTING_SK_PREFIX : DATA_SK_PREFIX
+    const masterTypeCode = skSplit[0]
+    await this.prismaService.master.upsert({
+      where: {
+        id: cmd.id,
+      },
+      update: {
+        csk: cmd.sk,
+        name: cmd.name,
+        version: cmd.version,
+        seq: cmd.seq,
+        updatedAt: cmd.updatedAt,
+        updatedBy: cmd.updatedBy,
+        updatedIp: cmd.updatedIp,
+        isDeleted: cmd.isDeleted || false,
+
+        attributes: cmd.attributes as object,
+      },
+      create: {
+        id: cmd.id,
+        cpk: cmd.pk,
+        csk: cmd.sk,
+        pk: cmd.pk,
+        sk,
+        masterType,
+        masterTypeCode,
+        masterCode: skSplit[1],
+        tenantCode: cmd.tenantCode,
+        code: sk,
+        name: cmd.name,
+        version: cmd.version,
+        seq: cmd.seq,
+        createdAt: cmd.createdAt,
+        createdBy: cmd.createdBy,
+        createdIp: cmd.createdIp,
+        updatedAt: cmd.updatedAt,
+        updatedBy: cmd.updatedBy,
+        updatedIp: cmd.updatedIp,
+        isDeleted: cmd.isDeleted || false,
+
+        attributes: cmd.attributes as object,
+      },
+    })
+  }
+  async down(cmd: CommandModel): Promise<any> {
+    this.logger.debug(cmd)
+  }
+}

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

@@ -0,0 +1,3 @@
+import { StepFunctionTaskEvent } from '@mbc-cqrs-serverless/task'
+
+export class MasterSfnTaskEvent extends StepFunctionTaskEvent {}

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

@@ -0,0 +1,334 @@
+import {
+  DataModel,
+  DataService,
+  DynamoDbService,
+  EventHandler,
+  extractInvokeContext,
+  IEventHandler,
+  IInvoke,
+  KEY_SEPARATOR,
+} from '@mbc-cqrs-serverless/core'
+import {
+  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 {
+  CopyType,
+  DataCopyMode,
+  DataCopyOptionDto,
+  MasterCopyDto,
+} from '../dto/master-copy.dto'
+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/helpers/get-order.ts

@@ -0,0 +1,19 @@
+import { Prisma } from '@prisma/client'
+
+export function getOrderBy(order: string) {
+  let orderValue: Prisma.SortOrder = Prisma.SortOrder.asc,
+    orderKey = order
+  if (order.startsWith('-')) {
+    orderValue = Prisma.SortOrder.desc
+    orderKey = order.slice(1)
+  }
+
+  return { [orderKey]: orderValue }
+}
+
+export function getOrderBys<T>(orders: string[]): T[] {
+  if (!orders) {
+    return undefined
+  }
+  return orders.map((order) => getOrderBy(order)) as T[]
+}

package/src/templates/master/helpers/id.ts

@@ -0,0 +1,42 @@
+import { KEY_SEPARATOR } from '@mbc-cqrs-serverless/core'
+import { RotateByEnum } from '@mbc-cqrs-serverless/sequence'
+
+import { MASTER_PK_PREFIX } from './key'
+
+const genSequenceSk = (
+  seqSettingCode: string,
+  settingCode: string,
+  rotateBy: RotateByEnum,
+) =>
+  `${seqSettingCode}${KEY_SEPARATOR}${settingCode}${KEY_SEPARATOR}${rotateBy}`
+
+const sequencePk = (tenantCode: string) => `SEQ${KEY_SEPARATOR}${tenantCode}`
+
+function generateMasterPk(tenantCode: string) {
+  return `${MASTER_PK_PREFIX}${KEY_SEPARATOR}${tenantCode}`
+}
+
+function parsePk(pk: string): { type: string; tenantCode: string } {
+  if (pk.split(KEY_SEPARATOR).length !== 2) {
+    throw new Error('Invalid PK')
+  }
+  const [type, tenantCode] = pk.split(KEY_SEPARATOR)
+  return {
+    type,
+    tenantCode,
+  }
+}
+function parseId(masterId: string): { pk: string; sk: string } {
+  const parts = masterId.split('#')
+
+  if (parts.length < 4 || parts[0] !== 'MASTER') {
+    throw new Error('Invalid masterId format')
+  }
+
+  const pk = `${parts[0]}#${parts[1]}`
+  const sk = `${parts[2]}#${parts[3]}`
+
+  return { pk, sk }
+}
+
+export { generateMasterPk, genSequenceSk, parseId, parsePk, sequencePk }

package/src/templates/master/helpers/index.ts

@@ -0,0 +1,3 @@
+export * from './get-order'
+export * from './id'
+export * from './key'

package/src/templates/master/helpers/key.ts

@@ -0,0 +1,11 @@
+const MASTER_PK_PREFIX = 'MASTER'
+const SETTING_SK_PREFIX = 'MASTER_SETTING'
+const DATA_SK_PREFIX = 'MASTER_DATA'
+const MASTER_COPY_SK_PREFIX = 'MASTER_COPY'
+
+export {
+  DATA_SK_PREFIX,
+  MASTER_COPY_SK_PREFIX,
+  MASTER_PK_PREFIX,
+  SETTING_SK_PREFIX,
+}