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

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

@@ -1,334 +0,0 @@
-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/master-data.controller.ts

@@ -1,98 +0,0 @@
-import {
-  DetailDto,
-  getUserContext,
-  IInvoke,
-  INVOKE_CONTEXT,
-} from '@mbc-cqrs-serverless/core'
-import {
-  BadRequestException,
-  Body,
-  Controller,
-  Delete,
-  Get,
-  Injectable,
-  Param,
-  Post,
-  Put,
-  Query,
-} from '@nestjs/common'
-import { ApiTags } from '@nestjs/swagger'
-
-import { MasterDataCreateDto } from './dto/master-data-create.dto'
-import { MasterDataSearchDto } from './dto/master-data-search.dto'
-import { MasterDataUpdateDto } from './dto/master-data-update.dto'
-import { parsePk } from './helpers'
-import { CustomMasterDataService } from './master-data.service'
-
-@ApiTags('master-data')
-@Controller('api/master-data')
-@Injectable()
-export class MasterDataController {
-  constructor(private readonly masterDataService: CustomMasterDataService) {}
-
-  @Get('/')
-  async list(
-    @Query() searchDto: MasterDataSearchDto,
-    @INVOKE_CONTEXT() invokeContext: IInvoke,
-  ) {
-    return this.masterDataService.list(searchDto, invokeContext)
-  }
-
-  @Get('/:pk/:sk')
-  async getDetail(@Param() key: DetailDto) {
-    return this.masterDataService.getDetail(key)
-  }
-
-  @Post('/')
-  async create(
-    @Body() createDto: MasterDataCreateDto,
-    @INVOKE_CONTEXT() invokeContext: IInvoke,
-  ) {
-    return this.masterDataService.create(createDto, invokeContext)
-  }
-
-  @Put('/:pk/:sk')
-  async update(
-    @Param() key: DetailDto,
-    @Body() updateDto: MasterDataUpdateDto,
-    @INVOKE_CONTEXT() invokeContext: IInvoke,
-  ) {
-    const userContext = getUserContext(invokeContext)
-
-    const { tenantCode } = parsePk(key.pk)
-
-    if (userContext.tenantCode !== tenantCode) {
-      throw new BadRequestException('Invalid tenant code')
-    }
-    return this.masterDataService.update(key, updateDto, invokeContext)
-  }
-
-  @Delete('/:pk/:sk')
-  async delete(
-    @Param() key: DetailDto,
-    @INVOKE_CONTEXT() invokeContext: IInvoke,
-  ) {
-    const userContext = getUserContext(invokeContext)
-
-    const { tenantCode } = parsePk(key.pk)
-
-    if (userContext.tenantCode !== tenantCode) {
-      throw new BadRequestException('Invalid tenant code')
-    }
-
-    return this.masterDataService.delete(key, invokeContext)
-  }
-
-  @Post('/check-exist/:settingCode/:code')
-  async checkExistCode(
-    @Param('settingCode') settingCode: string,
-    @Param('code') code: string,
-    @INVOKE_CONTEXT() invokeContext: IInvoke,
-  ) {
-    return this.masterDataService.checkExistCode(
-      settingCode,
-      code,
-      invokeContext,
-    )
-  }
-}

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

@@ -1,181 +0,0 @@
-import {
-  DataService,
-  DetailDto,
-  getUserContext,
-  IInvoke,
-  UserContext,
-} from '@mbc-cqrs-serverless/core'
-import { MasterDataService } from '@mbc-cqrs-serverless/master'
-import { Injectable, NotFoundException, Param } from '@nestjs/common'
-import { Prisma } from '@prisma/client'
-import { PrismaService } from 'src/prisma'
-import { ulid } from 'ulid'
-
-import { MasterDataCreateDto } from './dto/master-data-create.dto'
-import { MasterDataSearchDto } from './dto/master-data-search.dto'
-import { MasterDataUpdateDto } from './dto/master-data-update.dto'
-import { MasterRdsEntity } from './dto/master-rds.entity'
-import { MasterRdsListEntity } from './dto/master-rds-list.entity'
-import { DATA_SK_PREFIX, getOrderBys, SETTING_SK_PREFIX } from './helpers'
-
-@Injectable()
-export class CustomMasterDataService {
-  constructor(
-    private readonly masterDataService: MasterDataService,
-    private readonly prismaService: PrismaService,
-    private readonly dataService: DataService,
-  ) {}
-
-  async list(searchDto: MasterDataSearchDto, invokeContext: IInvoke) {
-    const userContext = getUserContext(invokeContext)
-    const deletedSettingData = await this.prismaService.master.findMany({
-      where: {
-        tenantCode: this.getTenantCode(userContext),
-        isDeleted: true,
-        masterType: SETTING_SK_PREFIX,
-      },
-      select: {
-        masterCode: true,
-      },
-    })
-
-    const deletedSettingCode = deletedSettingData.map(
-      (setting) => setting.masterCode,
-    )
-
-    const where: Prisma.MasterWhereInput = {
-      tenantCode: this.getTenantCode(userContext),
-      masterType: DATA_SK_PREFIX,
-    }
-
-    if (deletedSettingCode.length > 0) {
-      where.masterTypeCode = {
-        notIn: deletedSettingCode,
-      }
-    }
-
-    if (searchDto.isDeleted === false || searchDto.isDeleted === undefined) {
-      where.isDeleted = false
-    }
-
-    const andConditions: Prisma.MasterWhereInput[] = []
-
-    if (searchDto.keyword?.trim()) {
-      andConditions.push({
-        name: { contains: searchDto.keyword.trim() },
-      })
-    }
-
-    if (searchDto.code?.trim()) {
-      andConditions.push({
-        masterCode: { contains: searchDto.code.trim() },
-      })
-    }
-
-    if (searchDto.settingCode?.trim()) {
-      andConditions.push({
-        masterTypeCode: searchDto.settingCode.trim(),
-      })
-    }
-
-    if (andConditions.length) {
-      where.AND = andConditions
-    }
-
-    const {
-      pageSize = 10,
-      page = 1,
-      orderBys = ['seq', 'masterCode'],
-    } = searchDto
-
-    const [total, items] = await Promise.all([
-      this.prismaService.master.count({ where }),
-      this.prismaService.master.findMany({
-        where,
-        take: pageSize,
-        skip: pageSize * (page - 1),
-        orderBy: getOrderBys<Prisma.MasterOrderByWithRelationInput>(orderBys),
-      }),
-    ])
-
-    return new MasterRdsListEntity({
-      total,
-      items: items.map((item) => new MasterRdsEntity(item)),
-    })
-  }
-
-  async getDetail(@Param() key: DetailDto) {
-    const data = await this.dataService.getItem(key)
-
-    if (!data) throw new NotFoundException()
-
-    return new MasterRdsEntity(data)
-  }
-
-  async create(createDto: MasterDataCreateDto, invokeContext: IInvoke) {
-    const userContext = getUserContext(invokeContext)
-    let seq = createDto?.seq
-    if (!seq) {
-      const maxSeq = await this.prismaService.master.aggregate({
-        _max: {
-          seq: true,
-        },
-        where: {
-          tenantCode: userContext.tenantCode,
-          masterType: DATA_SK_PREFIX,
-          masterTypeCode: createDto.settingCode,
-        },
-      })
-      seq = (maxSeq._max.seq ?? 0) + 1
-      createDto.attributes['seq'] = seq
-    }
-
-    return await this.masterDataService.create(
-      {
-        code: createDto.code ?? ulid(),
-        tenantCode: userContext.tenantCode,
-        name: createDto.name,
-        settingCode: createDto.settingCode,
-        attributes: createDto.attributes ?? {},
-        seq,
-      },
-      { invokeContext },
-    )
-  }
-
-  async update(
-    key: DetailDto,
-    updateDto: MasterDataUpdateDto,
-    invokeContext: IInvoke,
-  ) {
-    return await this.masterDataService.update(
-      key,
-      {
-        ...updateDto,
-      },
-      { invokeContext },
-    )
-  }
-
-  async delete(key: DetailDto, invokeContext: IInvoke) {
-    return this.masterDataService.delete(key, { invokeContext })
-  }
-
-  async checkExistCode(
-    settingCode: string,
-    code: string,
-    invokeContext: IInvoke,
-  ) {
-    const userContext = getUserContext(invokeContext)
-
-    return this.masterDataService.checkExistCode(
-      userContext.tenantCode,
-      settingCode,
-      code,
-    )
-  }
-
-  private getTenantCode(userContext: UserContext): string {
-    return userContext.tenantCode
-  }
-}

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

@@ -1,103 +0,0 @@
-import {
-  DetailDto,
-  getUserContext,
-  IInvoke,
-  INVOKE_CONTEXT,
-} from '@mbc-cqrs-serverless/core'
-import { CommonSettingDto } from '@mbc-cqrs-serverless/master/dist/dto'
-import {
-  BadRequestException,
-  Body,
-  Controller,
-  Delete,
-  Get,
-  Injectable,
-  Param,
-  Post,
-  Put,
-  Query,
-} from '@nestjs/common'
-import { ApiTags } from '@nestjs/swagger'
-
-import { MasterCopyDto } from './dto/master-copy.dto'
-import { MasterSettingSearchDto } from './dto/master-setting-search.dto'
-import { MasterSettingUpdateDto } from './dto/master-setting-update.dto'
-import { parsePk } from './helpers'
-import { CustomMasterSettingService } from './master-setting.service'
-
-@ApiTags('master-setting')
-@Controller('api/master-setting')
-@Injectable()
-export class MasterSettingController {
-  constructor(
-    private readonly masterSettingService: CustomMasterSettingService,
-  ) {}
-
-  @Get('/')
-  async list(
-    @Query() searchDto: MasterSettingSearchDto,
-    @INVOKE_CONTEXT() invokeContext: IInvoke,
-  ) {
-    return this.masterSettingService.list(searchDto, invokeContext)
-  }
-
-  @Get('/:pk/:sk')
-  async getDetail(@Param() key: DetailDto) {
-    return this.masterSettingService.getDetail(key)
-  }
-
-  @Post('/')
-  async create(
-    @Body() createDto: CommonSettingDto,
-    @INVOKE_CONTEXT() invokeContext: IInvoke,
-  ) {
-    return this.masterSettingService.create(createDto, invokeContext)
-  }
-
-  @Put('/:pk/:sk')
-  async update(
-    @Param() key: DetailDto,
-    @Body() updateDto: MasterSettingUpdateDto,
-    @INVOKE_CONTEXT() invokeContext: IInvoke,
-  ) {
-    const userContext = getUserContext(invokeContext)
-
-    const { tenantCode } = parsePk(key.pk)
-
-    if (userContext.tenantCode !== tenantCode) {
-      throw new BadRequestException('Invalid tenant code')
-    }
-    return this.masterSettingService.update(key, updateDto, invokeContext)
-  }
-
-  @Delete('/:pk/:sk')
-  async delete(
-    @Param() key: DetailDto,
-    @INVOKE_CONTEXT() invokeContext: IInvoke,
-  ) {
-    const userContext = getUserContext(invokeContext)
-
-    const { tenantCode } = parsePk(key.pk)
-
-    if (userContext.tenantCode !== tenantCode) {
-      throw new BadRequestException('Invalid tenant code')
-    }
-    return this.masterSettingService.delete(key, invokeContext)
-  }
-
-  @Post('/check-exist/:code')
-  async checkExistCode(
-    @Param('code') code: string,
-    @INVOKE_CONTEXT() invokeContext: IInvoke,
-  ) {
-    return this.masterSettingService.checkExistCode(code, invokeContext)
-  }
-
-  @Post('/copy')
-  async copyMaster(
-    @INVOKE_CONTEXT() invokeContext: IInvoke,
-    @Body() masterCopyDto: MasterCopyDto,
-  ): Promise<any> {
-    return this.masterSettingService.copy(masterCopyDto, { invokeContext })
-  }
-}