@things-factory/operato-tools 8.0.0-beta.8 → 8.0.0

package/server/service/tool-entity/create-service.ts

@@ -0,0 +1,1160 @@
+import { Arg, Ctx, Query, Resolver } from 'type-graphql'
+import { getRepository } from '@things-factory/shell'
+import { Entity, EntityColumn } from '@things-factory/resource-base'
+
+const { camelCase, startCase, snakeCase, kebabCase } = require('lodash')
+const { plural } = require('pluralize')
+const fs = require('fs')
+
+@Resolver()
+export class OperatoToolCreateService {
+  @Query(returns => Boolean, { description: 'Operato Tool Create Service' })
+  async toolCreateService(@Arg('id') id: string, @Ctx() context: any): Promise<Boolean> {
+    const { domain } = context.state
+    // Entity 조회
+    const entity: Entity = await getRepository(Entity).findOne({
+      where: {
+        id
+      }
+    })
+
+    // Entity 컬럼 조회
+    const entityColumns: EntityColumn[] = await getRepository(EntityColumn).find({
+      where: {
+        domain: { id: domain.id },
+        entity: { id: entity.id }
+      }
+    })
+
+    let { name = '', bundle = '' } = entity || {}
+
+    // 프로젝트 Root Path 구하기
+    let appRootPath: string = this.getProjectRootPath()
+    let serviceName: string = kebabCase(name)
+    // 서비스 경로 생성
+    await this.createServicePath(appRootPath, bundle, serviceName)
+
+    // 서비스 파일 생성
+    await this.createServiceFiles(appRootPath, bundle, name, serviceName, entity, entityColumns)
+
+    return true
+  }
+
+  /**
+   * 서비스 연관 파일 생성
+   * @param appRootPath
+   * @param moduleName
+   * @param name
+   * @param serviceName
+   * @param entity
+   * @param entityColumns
+   */
+  async createServiceFiles(
+    appRootPath: string,
+    moduleName: string,
+    name: string,
+    serviceName: string,
+    entity: Entity,
+    entityColumns: EntityColumn[]
+  ) {
+    // 이름 케이스 워드 만들기
+    let nameMap = {
+      name: serviceName,
+      tableName: entity.tableName,
+      pascalCaseName: startCase(camelCase(name)).replace(/ /g, ''),
+      camelCaseName: camelCase(name),
+      snakeCaseName: snakeCase(name),
+      pluralPascalCaseName: startCase(camelCase(plural(name))).replace(/ /g, ''),
+      pluralCamelCaseName: camelCase(plural(name))
+    }
+    let servicePath = `${appRootPath}/packages/${moduleName}/server/service/`
+
+    if (['JSON', 'COPY'].includes(entity.dataProp)) {
+      await this.createHistoryServiceFiles(servicePath, serviceName, entity, entityColumns, nameMap)
+    } else {
+      await this.createNoHistoryServiceFiels(servicePath, serviceName, entity, entityColumns, nameMap)
+    }
+  }
+
+  async createHistoryServiceFiles(
+    servicePath: string,
+    serviceName: string,
+    entity: Entity,
+    entityColumns: EntityColumn[],
+    nameMap: any
+  ) {
+    // 서비스 연관 파일 생성
+    await this.writeFile(servicePath + `${serviceName}/index.ts`, serviceHistoryIndex, nameMap)
+
+    // Entity
+    let entityText = this.createEntityText(entity, entityColumns)
+    await this.writeFile(servicePath + `${serviceName}/${serviceName}.ts`, entityText, nameMap)
+    await this.writeFile(servicePath + `${serviceName}/${serviceName}-query.ts`, serviceQuery, nameMap)
+    await this.writeFile(servicePath + `${serviceName}/${serviceName}-mutation.ts`, serviceMutation, nameMap)
+    // TYPE
+    let typeText = this.createTypeText(entityColumns)
+    await this.writeFile(servicePath + `${serviceName}/${serviceName}-type.ts`, typeText, nameMap)
+
+    // 이력관리 entity 생성
+    let historyText = this.createHistoryEntityText(entity, entityColumns)
+    await this.writeFile(servicePath + `${serviceName}/${serviceName}-history.ts`, historyText, nameMap)
+    let entitySubscriberEntityToJson = ''
+    if (entity.dataProp == 'JSON') {
+      entitySubscriberEntityToJson = `
+  public createHistoryEntity(manager, entity) {
+    let history = manager.create(this.historyEntity, entity);
+    history.historyJson = JSON.stringify(entity);
+    return history;
+  }
+        `
+      await this.writeFile(servicePath + `${serviceName}/event-subscriber.ts`, serviceEntitySubscriber, nameMap)
+    } else {
+      entitySubscriberEntityToJson = ''
+    }
+    let subscriberTxt = serviceEntitySubscriber.replace(/{{entityToJson}}/g, entitySubscriberEntityToJson)
+    await this.writeFile(servicePath + `${serviceName}/event-subscriber.ts`, subscriberTxt, nameMap)
+    await this.writeFile(servicePath + `${serviceName}/${serviceName}-history-query.ts`, serviceHistoryQuery, nameMap)
+    // TYPE
+    await this.writeFile(servicePath + `${serviceName}/${serviceName}-history-type.ts`, sereviceHistoryType, nameMap)
+
+    // 전체 서비스 index.ts 파일
+    let allServiceIdxPath = servicePath + 'index.ts'
+    if ((await this.existsPath(allServiceIdxPath)) == false) {
+      await this.writeFile(allServiceIdxPath, allIndex, nameMap)
+    }
+
+    let allIdxFileTxt = await fs.readFileSync(allServiceIdxPath, 'utf8')
+
+    if (allIdxFileTxt.indexOf(`export * from './${nameMap.name}/${nameMap.name}-history'`) < 0) {
+      allIdxFileTxt = allIdxFileTxt.replace(
+        /\/\* EXPORT ENTITY TYPES \*\//,
+        `/* EXPORT ENTITY TYPES */\nexport * from './${nameMap.name}/${nameMap.name}-history'`
+      )
+    }
+
+    if (allIdxFileTxt.indexOf(`export * from './${nameMap.name}/${nameMap.name}'`) < 0) {
+      allIdxFileTxt = allIdxFileTxt.replace(
+        /\/\* EXPORT ENTITY TYPES \*\//,
+        `/* EXPORT ENTITY TYPES */\nexport * from './${nameMap.name}/${nameMap.name}'`
+      )
+    }
+
+    if (
+      allIdxFileTxt.indexOf(
+        `import { entities as ${nameMap.pascalCaseName}Entities, resolvers as ${nameMap.pascalCaseName}Resolvers, subscribers as ${nameMap.pascalCaseName}EntitySubscribers } from './${nameMap.name}'`
+      ) < 0
+    ) {
+      allIdxFileTxt = allIdxFileTxt.replace(
+        /\/\* IMPORT ENTITIES AND RESOLVERS \*\//,
+        `/* IMPORT ENTITIES AND RESOLVERS */\nimport { entities as ${nameMap.pascalCaseName}Entities, resolvers as ${nameMap.pascalCaseName}Resolvers, subscribers as ${nameMap.pascalCaseName}EntitySubscribers } from './${nameMap.name}'`
+      )
+    }
+
+    if (allIdxFileTxt.indexOf(`...${nameMap.pascalCaseName}Entities,`) < 0) {
+      allIdxFileTxt = allIdxFileTxt.replace(
+        /\/\* ENTITIES \*\//,
+        `/* ENTITIES */\n\t...${nameMap.pascalCaseName}Entities,`
+      )
+    }
+
+    if (allIdxFileTxt.indexOf(`...${nameMap.pascalCaseName}Resolvers,`) < 0) {
+      allIdxFileTxt = allIdxFileTxt.replace(
+        /\/\* RESOLVER CLASSES \*\//,
+        `/* RESOLVER CLASSES */\n\t\t...${nameMap.pascalCaseName}Resolvers,`
+      )
+    }
+
+    if (allIdxFileTxt.indexOf(`...${nameMap.pascalCaseName}EntitySubscribers,`) < 0) {
+      allIdxFileTxt = allIdxFileTxt.replace(
+        /\/\* SUBSCRIBERS \*\//,
+        `/* SUBSCRIBERS */\n\t\t...${nameMap.pascalCaseName}EntitySubscribers,`
+      )
+    }
+
+    await this.writeFile(allServiceIdxPath, allIdxFileTxt, nameMap)
+  }
+
+  async createNoHistoryServiceFiels(
+    servicePath: string,
+    serviceName: string,
+    entity: Entity,
+    entityColumns: EntityColumn[],
+    nameMap: any
+  ) {
+    // 서비스 연관 파일 생성
+    await this.writeFile(servicePath + `${serviceName}/index.ts`, serviceIndex, nameMap)
+
+    await this.writeFile(servicePath + `${serviceName}/${serviceName}-query.ts`, serviceQuery, nameMap)
+    await this.writeFile(servicePath + `${serviceName}/${serviceName}-mutation.ts`, serviceMutation, nameMap)
+
+    // Entity
+    let entityText = this.createEntityText(entity, entityColumns)
+    await this.writeFile(servicePath + `${serviceName}/${serviceName}.ts`, entityText, nameMap)
+
+    // TYPE
+    let typeText = this.createTypeText(entityColumns)
+    await this.writeFile(servicePath + `${serviceName}/${serviceName}-type.ts`, typeText, nameMap)
+
+    // 전체 서비스 index.ts 파일
+    let allServiceIdxPath = servicePath + 'index.ts'
+    if ((await this.existsPath(allServiceIdxPath)) == false) {
+      await this.writeFile(allServiceIdxPath, allIndex, nameMap)
+    }
+
+    let allIdxFileTxt = await fs.readFileSync(allServiceIdxPath, 'utf8')
+
+    if (allIdxFileTxt.indexOf(`export * from './${nameMap.name}/${nameMap.name}'`) < 0) {
+      allIdxFileTxt = allIdxFileTxt.replace(
+        /\/\* EXPORT ENTITY TYPES \*\//,
+        `/* EXPORT ENTITY TYPES */\nexport * from './${nameMap.name}/${nameMap.name}'`
+      )
+    }
+
+    if (
+      allIdxFileTxt.indexOf(
+        `import { entities as ${nameMap.pascalCaseName}Entities, resolvers as ${nameMap.pascalCaseName}Resolvers } from './${nameMap.name}'`
+      ) < 0
+    ) {
+      allIdxFileTxt = allIdxFileTxt.replace(
+        /\/\* IMPORT ENTITIES AND RESOLVERS \*\//,
+        `/* IMPORT ENTITIES AND RESOLVERS */\nimport { entities as ${nameMap.pascalCaseName}Entities, resolvers as ${nameMap.pascalCaseName}Resolvers } from './${nameMap.name}'`
+      )
+    }
+
+    if (allIdxFileTxt.indexOf(`...${nameMap.pascalCaseName}Entities,`) < 0) {
+      allIdxFileTxt = allIdxFileTxt.replace(
+        /\/\* ENTITIES \*\//,
+        `/* ENTITIES */\n\t...${nameMap.pascalCaseName}Entities,`
+      )
+    }
+
+    if (allIdxFileTxt.indexOf(`...${nameMap.pascalCaseName}Resolvers,`) < 0) {
+      allIdxFileTxt = allIdxFileTxt.replace(
+        /\/\* RESOLVER CLASSES \*\//,
+        `/* RESOLVER CLASSES */\n\t\t...${nameMap.pascalCaseName}Resolvers,`
+      )
+    }
+
+    await this.writeFile(allServiceIdxPath, allIdxFileTxt, nameMap)
+  }
+
+  /**
+   * 엔티티 타입 텍스트
+   * @param entityColumns
+   * @returns
+   */
+  createTypeText(entityColumns: EntityColumn[]) {
+    let typeText = sereviceType
+
+    let newTypeColumns = entityColumns.map(column => {
+      if (column.name == 'id') return ''
+      if (column.name == 'domain_id') return ''
+      if (column.name == 'created_at') return ''
+      if (column.name == 'updated_at') return ''
+      if (column.name == 'creator_id') return ''
+      if (column.name == 'updater_id') return ''
+
+      let fieldType: string = this.getFieldType(column)
+      let colTxtType: string = this.getColTxtType(column)
+
+      let colName = camelCase(column.name)
+      let fieldAnn = `@Field(${fieldType.length == 0 ? '' : 'type =>' + fieldType + ','} { nullable: ${column.nullable} })`
+      let columnTxt = `${colName}${column.nullable ? '?' : ''}: ${colTxtType}`
+
+      return '  ' + fieldAnn + '\n  ' + columnTxt + '\n'
+    })
+
+    typeText = typeText.replace(/{{newTypeColumns}}/g, newTypeColumns.join('\n'))
+
+    let patchTypeColumns = entityColumns.map(column => {
+      if (column.name == 'id') return ''
+      if (column.name == 'domain_id') return ''
+      if (column.name == 'created_at') return ''
+      if (column.name == 'updated_at') return ''
+      if (column.name == 'creator_id') return ''
+      if (column.name == 'updater_id') return ''
+
+      let fieldType: string = this.getFieldType(column)
+      let colTxtType: string = this.getColTxtType(column)
+
+      // patch ?
+      column.nullable = true
+
+      let colName = camelCase(column.name)
+      let fieldAnn = `@Field(${fieldType.length == 0 ? '' : 'type =>' + fieldType + ','} { nullable: ${column.nullable} })`
+      let columnTxt = `${colName}${column.nullable ? '?' : ''}: ${colTxtType}`
+
+      return '  ' + fieldAnn + '\n  ' + columnTxt + '\n'
+    })
+
+    typeText = typeText.replace(/{{patchTypeColumns}}/g, patchTypeColumns.join('\n'))
+
+    return typeText
+  }
+
+  /**
+   * 엔티티 생성 텍스트
+   * @param entity
+   * @param entityColumns
+   * @returns
+   */
+  createEntityText(entity: Entity, entityColumns: EntityColumn[]) {
+    let entityText = serviceEntity
+
+    // 컬럼 정렬
+    let sortedCols: EntityColumn[] = entityColumns.sort(function (a, b) {
+      return a.rank - b.rank
+    })
+
+    // 컬럼 정보 txt 변환
+    let entityColsText: string[] = sortedCols.map(x => {
+      return this.columnToEntityColumn(x)
+    })
+
+    if (['COPY', 'JSON'].includes(entity.dataProp)) {
+      entityColsText.push(`
+  @VersionColumn({ default: 1 })
+  @Field({ nullable: true })
+  dataRevisionNo?: number = 1`)
+    }
+
+    entityText = entityText.replace(/{{entityColumns}}/g, entityColsText.join('\n'))
+
+    // index 정보
+    let indexAnn = ``
+    let sortedIdxCols: EntityColumn[] = entityColumns
+      .filter(x => x.uniqRank && x.uniqRank > 0)
+      .sort(function (a, b) {
+        return a.uniqRank - b.uniqRank
+      })
+
+    if (sortedIdxCols.length > 0) {
+      indexAnn = `@Index('ix_{{snakeCase name}}_0', ({{camelCase name}}: {{pascalCase name}}) => [{{indexColumns}}], { unique: true })`
+
+      let idxColumns = sortedIdxCols.map(x => {
+        let colName = x.name
+        if (x.name == 'domain_id') colName = 'domain'
+        if (x.name == 'creator_id') colName = 'creator'
+        if (x.name == 'updater_id') colName = 'updater'
+
+        return '{{camelCase name}}.' + camelCase(colName)
+      })
+
+      indexAnn = indexAnn.replace(/{{indexColumns}}/g, idxColumns.join(','))
+    }
+    entityText = entityText.replace(/{{indexAnn}}/g, indexAnn)
+
+    return entityText
+  }
+
+  /**
+   * 이력관리 엔티티 생성 텍스트
+   * @param entity
+   * @param entityColumns
+   * @returns
+   */
+  createHistoryEntityText(entity: Entity, entityColumns: EntityColumn[]) {
+    let entityText = entity.dataProp == 'JSON' ? serviceEntityHistJson : serviceEntityHistCopy
+
+    // 컬럼 정렬
+    let sortedCols: EntityColumn[] = entityColumns.sort(function (a, b) {
+      return a.rank - b.rank
+    })
+
+    // 컬럼 정보 txt 변환
+    let entityColsText: string[] = sortedCols.map(x => {
+      return this.columnToEntityColumn(x)
+    })
+
+    entityText = entityText.replace(/{{entityColumns}}/g, entityColsText.join('\n'))
+    return entityText
+  }
+
+  /**
+   * EntityColumn to entity column Text
+   * @param column
+   * @returns
+   */
+  columnToEntityColumn(column: EntityColumn) {
+    if (column.name == 'id') return ''
+    if (column.name == 'domain_id') return ''
+    if (column.name == 'created_at') return ''
+    if (column.name == 'updated_at') return ''
+    if (column.name == 'creator_id') return ''
+    if (column.name == 'updater_id') return ''
+
+    let colType: string = column.colType
+    if (column.colType == 'double') colType = 'double precision'
+    if (column.colType == 'long') colType = 'bigint'
+    if (column.colType == 'string') colType = 'character varying'
+    if (column.colType == 'datetime') colType = 'timestamp without time zone'
+
+    let colSize: string = ''
+    if (column.colType == 'string') {
+      //@ts-ignore
+      colSize = column.colSize
+    }
+
+    let fieldType: string = this.getFieldType(column)
+    let colTxtType: string = this.getColTxtType(column)
+
+    let colName = camelCase(column.name)
+
+    let columnAnn = `@Column({name:'${column.name}', type: '${colType}', nullable: ${column.nullable} ${colSize.length == 0 ? '' : ',length:' + colSize} })`
+    let fieldAnn = `@Field(${fieldType.length == 0 ? '' : 'type =>' + fieldType + ','} { nullable: ${column.nullable} })`
+    let columnTxt = `${colName}${column.nullable ? '?' : ''}: ${colTxtType}`
+
+    return '  ' + columnAnn + '\n  ' + fieldAnn + '\n  ' + columnTxt + '\n'
+  }
+
+  getFieldType(column: EntityColumn) {
+    let fieldType: string = ''
+
+    if (column.colType == 'double') fieldType = 'Float'
+    if (column.colType == 'float') fieldType = 'Float'
+    if (column.colType == 'long') fieldType = 'Int'
+    if (column.colType == 'integer') fieldType = 'Int'
+
+    return fieldType
+  }
+
+  getColTxtType(column: EntityColumn) {
+    let colTxtType: string = column.colType
+    if (column.colType == 'decimal') colTxtType = 'number'
+    if (column.colType == 'double') colTxtType = 'number'
+    if (column.colType == 'float') colTxtType = 'number'
+    if (column.colType == 'integer') colTxtType = 'number'
+    if (column.colType == 'long') colTxtType = 'number'
+    if (column.colType == 'datetime') colTxtType = 'Date'
+    if (column.colType == 'date') colTxtType = 'Date'
+    if (column.colType == 'text') colTxtType = 'string'
+    return colTxtType
+  }
+
+  /**
+   * 파일 생성
+   * @param filePath
+   * @param fileText
+   * @param nameMap
+   */
+  async writeFile(filePath: string, fileText: string, nameMap: any) {
+    await fs.writeFileSync(filePath, this.replaceNamesMap(fileText, nameMap), 'utf8')
+  }
+
+  /**
+   * 문자열 치환
+   * @param text
+   * @param nameMap
+   * @returns
+   */
+  replaceNamesMap(text: string, nameMap: any) {
+    return text
+      .replace(/{{pascalCase name}}/g, nameMap.pascalCaseName)
+      .replace(/{{camelCase name}}/g, nameMap.camelCaseName)
+      .replace(/{{snakeCase name}}/g, nameMap.snakeCaseName)
+      .replace(/{{pluralPascalCase name}}/g, nameMap.pluralPascalCaseName)
+      .replace(/{{pluralCamelCase name}}/g, nameMap.pluralCamelCaseName)
+      .replace(/{{tableName}}/g, nameMap.tableName)
+      .replace(/{{name}}/g, nameMap.name)
+  }
+
+  /**
+   * 서비스 경로 만들기
+   * @param appRootPath
+   * @param moduleName
+   * @param serviceName
+   */
+  async createServicePath(appRootPath: string, moduleName: string, serviceName: string) {
+    let path: string = appRootPath + '/' + 'packages'
+    await this.createDir(path)
+
+    path = path + '/' + moduleName
+    await this.createDir(path)
+
+    path = path + '/server'
+    await this.createDir(path)
+
+    path = path + '/service'
+    await this.createDir(path)
+
+    path = path + '/' + serviceName
+    await this.createDir(path)
+  }
+
+  /**
+   * 프로젝트 Root Path 구하기
+   * @returns String
+   */
+  getProjectRootPath() {
+    let appPath: string = process.env.PWD
+    let splitPath: string[] = appPath.split('/')
+    let pathArr: string[] = []
+    for (let i = 0; i < splitPath.length; i++) {
+      if (splitPath[i] == 'packages') {
+        break
+      }
+
+      pathArr.push(splitPath[i])
+    }
+
+    return pathArr.join('/')
+  }
+
+  /**
+   * 디렉토리 생성
+   * @param path
+   */
+  async createDir(path: string) {
+    if ((await this.existsPath(path)) == false) fs.mkdirSync(path)
+  }
+
+  /**
+   * Path 존재 여부
+   * @param path
+   * @returns
+   */
+  async existsPath(path: string) {
+    return await fs.existsSync(path)
+  }
+}
+
+/* all service index text index.ts */
+const allIndex = `
+/* EXPORT ENTITY TYPES */
+
+/* IMPORT ENTITIES AND RESOLVERS */
+
+export const entities = [  
+  /* ENTITIES */
+] 
+
+
+export const schema = {
+  resolverClasses: [
+    /* RESOLVER CLASSES */
+  ] 
+}
+
+export const subscribers = [
+  /* SUBSCRIBERS */
+]
+`
+
+/* service index text index.ts */
+const serviceIndex = `
+import { {{pascalCase name}} } from './{{name}}'
+import { {{pascalCase name}}Query } from './{{name}}-query'
+import { {{pascalCase name}}Mutation } from './{{name}}-mutation'
+
+export const entities = [{{pascalCase name}}]
+export const resolvers = [{{pascalCase name}}Query, {{pascalCase name}}Mutation]
+`
+
+/* service index text index.ts */
+const serviceHistoryIndex = `
+import { {{pascalCase name}} } from './{{name}}'
+import { {{pascalCase name}}Query } from './{{name}}-query'
+import { {{pascalCase name}}HistoryQuery } from './{{name}}-history-query'
+import { {{pascalCase name}}Mutation } from './{{name}}-mutation'
+import { {{pascalCase name}}History } from './{{name}}-history'
+import { {{pascalCase name}}HistoryEntitySubscriber } from './event-subscriber'
+
+export const entities = [{{pascalCase name}}, {{pascalCase name}}History]
+export const resolvers = [{{pascalCase name}}Query, {{pascalCase name}}HistoryQuery, {{pascalCase name}}Mutation]
+export const subscribers = [{{pascalCase name}}HistoryEntitySubscriber]
+
+`
+
+/* service Query text {{name}}-query.ts */
+const serviceQuery = `
+import { Resolver, Query, FieldResolver, Root, Args, Arg, Ctx, Directive } from 'type-graphql'
+import { Domain, ListParam, convertListParams, getRepository, getQueryBuilderFromListParams } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+import { {{pascalCase name}} } from './{{name}}'
+import { {{pascalCase name}}List } from './{{name}}-type'
+
+@Resolver({{pascalCase name}})
+export class {{pascalCase name}}Query {
+  @Query(returns => {{pascalCase name}}, { description: 'To fetch a {{pascalCase name}}' })
+  async {{camelCase name}}(@Arg('id') id: string, @Ctx() context: any): Promise<{{pascalCase name}}> {
+    const { domain } = context.state
+    return await getRepository({{pascalCase name}}).findOne({
+      where: { domain: { id: domain.id }, id }
+    })
+  }
+
+  @Query(returns => {{pascalCase name}}List, { description: 'To fetch multiple {{pluralPascalCase name}}' })
+  async {{pluralCamelCase name}}(@Args(type => ListParam) params: ListParam, @Ctx() context: any): Promise<{{pascalCase name}}List> {
+    const { domain } = context.state
+
+    const queryBuilder = getQueryBuilderFromListParams({
+      domain,
+      params,
+      repository: await getRepository({{pascalCase name}})
+    })
+
+    const convertedParams = convertListParams(params, domain.id)
+    const [items, total] = await queryBuilder.getManyAndCount()
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() {{camelCase name}}: {{pascalCase name}}): Promise<Domain> {
+    return await getRepository(Domain).findOneBy({id:{{camelCase name}}.domainId})
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() {{camelCase name}}: {{pascalCase name}}): Promise<User> {
+    return await getRepository(User).findOneBy({id:{{camelCase name}}.updaterId})
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() {{camelCase name}}: {{pascalCase name}}): Promise<User> {
+    return await getRepository(User).findOneBy({id:{{camelCase name}}.creatorId})
+  }
+}
+`
+/* service Query text {{name}}-query.ts */
+const serviceHistoryQuery = `
+import { Resolver, Query, FieldResolver, Root, Args, Arg, Ctx, Directive } from 'type-graphql'
+import { Domain, ListParam, convertListParams, getRepository, getQueryBuilderFromListParams } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+import { {{pascalCase name}}History } from './{{name}}-history'
+import { {{pascalCase name}}HistoryList } from './{{name}}-history-type'
+
+@Resolver({{pascalCase name}}History)
+export class {{pascalCase name}}HistoryQuery {
+  @Query(returns => {{pascalCase name}}History, { description: 'To fetch a {{pascalCase name}}History' })
+  async {{camelCase name}}History(@Arg('id') id: string, @Ctx() context: any): Promise<{{pascalCase name}}History> {
+    const { domain } = context.state
+    return await getRepository({{pascalCase name}}History).findOne({
+      where: { domain: { id: domain.id }, id }
+    })
+  }
+
+  @Query(returns => {{pascalCase name}}HistoryList, { description: 'To fetch multiple {{pluralPascalCase name}}History' })
+  async {{camelCase name}}Histories(@Args(type => ListParam) params: ListParam, @Ctx() context: any): Promise<{{pascalCase name}}HistoryList> {
+    const { domain } = context.state
+
+    const queryBuilder = getQueryBuilderFromListParams({
+      domain,
+      params,
+      repository: await getRepository({{pascalCase name}}History)
+    })
+
+    const [items, total] = await queryBuilder.getManyAndCount()
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() {{camelCase name}}History: {{pascalCase name}}History): Promise<Domain> {
+    return await getRepository(Domain).findOneBy({id:{{camelCase name}}History.domainId})
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() {{camelCase name}}History: {{pascalCase name}}History): Promise<User> {
+    return await getRepository(User).findOneBy({id:{{camelCase name}}History.updaterId})
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() {{camelCase name}}History: {{pascalCase name}}History): Promise<User> {
+    return await getRepository(User).findOneBy({id:{{camelCase name}}History.creatorId})
+  }
+}
+`
+/* service mutation text {{name}}-mutation.ts */
+const serviceMutation = `
+import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
+import { In } from 'typeorm'
+import { {{pascalCase name}} } from './{{name}}'
+import { New{{pascalCase name}}, {{pascalCase name}}Patch } from './{{name}}-type'
+import { getRepository } from '@things-factory/shell'
+
+@Resolver({{pascalCase name}})
+export class {{pascalCase name}}Mutation {
+  @Directive('@transaction')
+  @Mutation(returns => {{pascalCase name}}, { description: 'To create new {{pascalCase name}}' })
+  async create{{pascalCase name}}(@Arg('{{camelCase name}}') {{camelCase name}}: New{{pascalCase name}}, @Ctx() context: any): Promise<{{pascalCase name}}> {
+    const { domain, user, tx } = context.state
+
+    return await tx.getRepository({{pascalCase name}}).save({
+      ...{{camelCase name}},
+      domain,
+      creator: user,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => {{pascalCase name}}, { description: 'To modify {{pascalCase name}} information' })
+  async update{{pascalCase name}}(
+    @Arg('id') id: string,
+    @Arg('patch') patch: {{pascalCase name}}Patch,
+    @Ctx() context: any
+  ): Promise<{{pascalCase name}}> {
+    const { domain, user, tx } = context.state
+
+    const repository = tx.getRepository({{pascalCase name}})
+    const {{camelCase name}} = await repository.findOne(
+      {
+        where: { domain: { id: domain.id }, id },
+        relations: ['domain', 'updater', 'creator']
+      }
+    )
+
+    return await repository.save({
+      ...{{camelCase name}},
+      ...patch,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => [{{pascalCase name}}], { description: "To modify multiple {{pluralPascalCase name}}' information" })
+  async updateMultiple{{pascalCase name}}(
+    @Arg('patches', type => [{{pascalCase name}}Patch]) patches: {{pascalCase name}}Patch[],
+    @Ctx() context: any
+  ): Promise<{{pascalCase name}}[]> {
+    const { domain, user, tx } = context.state
+
+    let results = []
+    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
+    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
+    const {{camelCase name}}Repo = tx.getRepository({{pascalCase name}})
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await {{camelCase name}}Repo.save({
+          ...newRecord,
+          domain,
+          creator: user,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: '+' })
+      }
+    }
+
+    if (_updateRecords.length > 0) {
+      for (let i = 0; i < _updateRecords.length; i++) {
+        const updRecord = _updateRecords[i]
+        const {{camelCase name}} = await {{camelCase name}}Repo.findOne({
+          where: { domain: { id: domain.id }, id:updRecord.id },
+          relations: ['domain', 'updater', 'creator']
+        })
+        
+        const result = await {{camelCase name}}Repo.save({
+          ...{{camelCase name}},
+          ...updRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete {{pascalCase name}}' })
+  async delete{{pascalCase name}}(@Arg('id') id: string, @Ctx() context: any): Promise<boolean> {
+    const { domain, tx, user } = context.state
+    await tx.getRepository({{pascalCase name}}).remove({ domain, id, updater:user })
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete multiple {{camelCase name}}s' })
+  async delete{{pluralPascalCase name}}(
+    @Arg('ids', type => [String]) ids: string[],
+    @Ctx() context: any
+  ): Promise<boolean> {
+    const { domain, tx, user } = context.state
+
+    let delEntitis = ids.map(id=>{
+      return {domain,id,updater:user}
+    })
+
+    await tx.getRepository({{pascalCase name}}).remove(delEntitis)
+
+    return true
+  }
+}
+`
+/* service type text {{name}}-type.ts */
+const sereviceType = `
+import { ObjectType, Field, InputType, Int, ID, Float, registerEnumType } from 'type-graphql'
+
+import { {{pascalCase name}} } from './{{name}}'
+
+@InputType()
+export class New{{pascalCase name}} {
+{{newTypeColumns}}
+}
+
+@InputType()
+export class {{pascalCase name}}Patch {
+  @Field(type => ID, { nullable: true })
+  id?: string
+
+{{patchTypeColumns}}
+
+  @Field()
+  cuFlag: string
+}
+
+@ObjectType()
+export class {{pascalCase name}}List {
+  @Field(type => [{{pascalCase name}}])
+  items: {{pascalCase name}}[]
+
+  @Field(type => Int)
+  total: number
+}
+`
+/* service type text {{name}}-type.ts */
+const sereviceHistoryType = `
+import { ObjectType, Field, InputType, Int, ID, Float, registerEnumType } from 'type-graphql'
+
+import { {{pascalCase name}}History } from './{{name}}-history'
+
+@ObjectType()
+export class {{pascalCase name}}HistoryList {
+  @Field(type => [{{pascalCase name}}History])
+  items: {{pascalCase name}}History[]
+
+  @Field(type => Int)
+  total: number
+}
+`
+
+/* service entity {{name}}.ts */
+const serviceEntity = `
+import {
+  CreateDateColumn,
+  UpdateDateColumn,
+  Entity,
+  Index,
+  Column,
+  RelationId,
+  ManyToOne,
+  PrimaryGeneratedColumn,
+  VersionColumn
+} from 'typeorm'
+import { ObjectType, Field, Int, ID, Float, registerEnumType } from 'type-graphql'
+
+import { Domain } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+
+@Entity('{{tableName}}')
+{{indexAnn}}
+@ObjectType({ description: 'Entity for {{pascalCase name}}' })
+export class {{pascalCase name}} {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain, {
+    createForeignKeyConstraints: false
+  })
+  @Field({ nullable: false })
+  domain: Domain
+
+  @RelationId(({{camelCase name}}: {{pascalCase name}}) => {{camelCase name}}.domain)
+  domainId: string
+
+{{entityColumns}}
+
+  @CreateDateColumn()
+  @Field({ nullable: true })
+  createdAt?: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true })
+  updatedAt?: Date
+
+  @ManyToOne(type => User, {
+    createForeignKeyConstraints: false,
+    nullable: true
+  })
+  @Field(type => User, { nullable: true })
+  creator?: User
+
+  @RelationId(({{camelCase name}}: {{pascalCase name}}) => {{camelCase name}}.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, {
+    createForeignKeyConstraints: false,
+    nullable: true
+  })
+  @Field(type => User, { nullable: true })
+  updater?: User
+
+  @RelationId(({{camelCase name}}: {{pascalCase name}}) => {{camelCase name}}.updater)
+  updaterId?: string
+}
+`
+
+/* service entity {{name}}-history.ts */
+const serviceEntityHistCopy = `
+import {
+  CreateDateColumn,
+  UpdateDateColumn,
+  Entity,
+  Index,
+  Column,
+  RelationId,
+  ManyToOne,
+  PrimaryGeneratedColumn,
+  VersionColumn
+} from 'typeorm'
+
+import {
+  HistoryActionColumn,
+  HistoryActionType,
+  HistoryEntityInterface,
+  HistoryOriginalIdColumn
+} from '@operato/typeorm-history'
+
+import { ObjectType, Field, Int, ID, Float, registerEnumType } from 'type-graphql'
+
+import { config } from '@things-factory/env'
+import { Domain, ScalarObject } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+
+const ORMCONFIG = config.get('ormconfig', {})
+const DATABASE_TYPE = ORMCONFIG.type
+
+import { {{pascalCase name}} } from './{{name}}'
+
+@Entity('{{tableName}}_histories')
+@Index('ix_{{snakeCase name}}_histories_0', ({{camelCase name}}History: {{pascalCase name}}History) => [{{camelCase name}}History.originalId,{{camelCase name}}History.dataRevisionNo], { unique: true })
+@Index('ix_{{snakeCase name}}_histories_1', ({{camelCase name}}History: {{pascalCase name}}History) => [{{camelCase name}}History.originalId ], { unique: false })
+@Index('ix_{{snakeCase name}}_histories_2', ({{camelCase name}}History: {{pascalCase name}}History) => [{{camelCase name}}History.domain, {{camelCase name}}History.originalId ], { unique: false })
+@Index('ix_{{snakeCase name}}_histories_3', ({{camelCase name}}History: {{pascalCase name}}History) => [{{camelCase name}}History.domain, {{camelCase name}}History.originalId, {{camelCase name}}History.dataRevisionNo], { unique: true })
+@ObjectType({ description: 'Entity for {{pascalCase name}}History' })
+export class {{pascalCase name}}History  implements HistoryEntityInterface<{{pascalCase name}}>{
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain, {
+    createForeignKeyConstraints: false
+  })
+  @Field({ nullable: false })
+  domain: Domain
+
+  @RelationId(({{camelCase name}}History: {{pascalCase name}}History) => {{camelCase name}}History.domain)
+  domainId: string
+
+  @HistoryOriginalIdColumn({type: 'character varying', nullable: false ,length:40})
+  @Field({ nullable: false })
+  public originalId!: string
+
+  @HistoryActionColumn({
+    nullable: false,
+    type:
+      DATABASE_TYPE == 'postgres' || DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb'
+        ? 'enum'
+        : DATABASE_TYPE == 'oracle'
+          ? 'varchar2'
+          : DATABASE_TYPE == 'mssql'
+            ? 'nvarchar'
+            : 'varchar',
+    enum:
+      DATABASE_TYPE == 'postgres' || DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb'
+        ? HistoryActionType
+        : undefined,
+    length: DATABASE_TYPE == 'postgres' || DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb' ? undefined: 32
+  })
+  @Field({ nullable: false })
+  public dataRevisionAction!: HistoryActionType
+
+  @Column({ default: 1, nullable: false })
+  @Field({ nullable: false })
+  dataRevisionNo?: number = 1
+
+{{entityColumns}}
+
+  @CreateDateColumn()
+  @Field({ nullable: true })
+  createdAt?: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true })
+  updatedAt?: Date
+
+  @ManyToOne(type => User, {
+    createForeignKeyConstraints: false,
+    nullable: true
+  })
+  @Field(type => User, { nullable: true })
+  creator?: User
+
+  @RelationId(({{camelCase name}}History: {{pascalCase name}}History) => {{camelCase name}}History.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, {
+    createForeignKeyConstraints: false,
+    nullable: true
+  })
+  @Field(type => User, { nullable: true })
+  updater?: User
+
+  @RelationId(({{camelCase name}}History: {{pascalCase name}}History) => {{camelCase name}}History.updater)
+  updaterId?: string
+}
+`
+
+/* service entity {{name}}-history.ts */
+const serviceEntityHistJson = `
+import {
+  CreateDateColumn,
+  UpdateDateColumn,
+  Entity,
+  Index,
+  Column,
+  RelationId,
+  ManyToOne,
+  PrimaryGeneratedColumn,
+  VersionColumn
+} from 'typeorm'
+
+import {
+  HistoryActionColumn,
+  HistoryActionType,
+  HistoryEntityInterface,
+  HistoryOriginalIdColumn
+} from '@operato/typeorm-history'
+
+import { ObjectType, Field, Int, ID, Float, registerEnumType } from 'type-graphql'
+
+import { config } from '@things-factory/env'
+import { Domain, ScalarObject } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+
+const ORMCONFIG = config.get('ormconfig', {})
+const DATABASE_TYPE = ORMCONFIG.type
+
+import { {{pascalCase name}} } from './{{name}}'
+
+@Entity('{{tableName}}_histories')
+@Index('ix_{{snakeCase name}}_histories_0', ({{camelCase name}}History: {{pascalCase name}}History) => [{{camelCase name}}History.originalId,{{camelCase name}}History.dataRevisionNo], { unique: true })
+@Index('ix_{{snakeCase name}}_histories_1', ({{camelCase name}}History: {{pascalCase name}}History) => [{{camelCase name}}History.originalId ], { unique: false })
+@Index('ix_{{snakeCase name}}_histories_2', ({{camelCase name}}History: {{pascalCase name}}History) => [{{camelCase name}}History.domain, {{camelCase name}}History.originalId ], { unique: false })
+@Index('ix_{{snakeCase name}}_histories_3', ({{camelCase name}}History: {{pascalCase name}}History) => [{{camelCase name}}History.domain, {{camelCase name}}History.originalId, {{camelCase name}}History.dataRevisionNo], { unique: true })
+@ObjectType({ description: 'Entity for {{pascalCase name}}History' })
+export class {{pascalCase name}}History  implements HistoryEntityInterface<{{pascalCase name}}>{
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain, {
+    createForeignKeyConstraints: false
+  })
+  @Field({ nullable: false })
+  domain: Domain
+
+  @RelationId(({{camelCase name}}History: {{pascalCase name}}History) => {{camelCase name}}History.domain)
+  domainId: string
+
+  @HistoryOriginalIdColumn({type: 'character varying', nullable: false ,length:40})
+  @Field({ nullable: false })
+  public originalId!: string
+
+  @HistoryActionColumn({
+    nullable: false,
+    type:
+      DATABASE_TYPE == 'postgres' || DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb'
+        ? 'enum'
+        : DATABASE_TYPE == 'oracle'
+          ? 'varchar2'
+          : DATABASE_TYPE == 'mssql'
+            ? 'nvarchar'
+            : 'varchar',
+    enum:
+      DATABASE_TYPE == 'postgres' || DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb'
+        ? HistoryActionType
+        : undefined,
+    length: DATABASE_TYPE == 'postgres' || DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb' ? undefined: 32
+  })
+  @Field({ nullable: false })
+  public dataRevisionAction!: HistoryActionType
+
+  @Column({ default: 1, nullable: false })
+  @Field({ nullable: false })
+  dataRevisionNo?: number = 1
+
+  @Column('simple-json', { nullable: true })
+  @Field(type => ScalarObject, { nullable: true })
+  historyJson?: any
+
+  @CreateDateColumn()
+  @Field({ nullable: true })
+  createdAt?: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true })
+  updatedAt?: Date
+
+  @ManyToOne(type => User, {
+    createForeignKeyConstraints: false,
+    nullable: true
+  })
+  @Field(type => User, { nullable: true })
+  creator?: User
+
+  @RelationId(({{camelCase name}}History: {{pascalCase name}}History) => {{camelCase name}}History.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, {
+    createForeignKeyConstraints: false,
+    nullable: true
+  })
+  @Field(type => User, { nullable: true })
+  updater?: User
+
+  @RelationId(({{camelCase name}}History: {{pascalCase name}}History) => {{camelCase name}}History.updater)
+  updaterId?: string
+}
+`
+
+/* service entity subscriber event-subscriber.ts */
+const serviceEntitySubscriber = `
+import { EventSubscriber } from 'typeorm'
+import { HistoryEntitySubscriber } from '@operato/typeorm-history'
+
+import { {{pascalCase name}} } from './{{name}}'
+import { {{pascalCase name}}History } from './{{name}}-history'
+import { getRepository } from '@things-factory/shell'
+
+@EventSubscriber()
+export class {{pascalCase name}}HistoryEntitySubscriber extends HistoryEntitySubscriber<{{pascalCase name}},{{pascalCase name}}History> {
+  public get entity() {
+    return {{pascalCase name}}
+  }
+
+  public get historyEntity() {
+    return {{pascalCase name}}History
+  }
+
+  {{entityToJson}}
+
+  async beforeRemoveHistory(history:{{pascalCase name}}History,entity:{{pascalCase name}}){
+    let repo = getRepository({{pascalCase name}}History);
+    const revNo = await repo.createQueryBuilder()
+                  .select('max(data_revision_no)', 'rev_no')
+                  .where('domain_id = :domainId', { domainId: entity.domain.id })
+                  .andWhere('original_id = :originalId', { originalId: entity.id })
+                  .getRawOne()
+    
+    history.dataRevisionNo = revNo ? revNo.rev_no + 1 : 1;
+    return history;
+  }
+}
+`