@things-factory/operato-tools 7.0.0-y.0 → 7.0.1-alpha.0

package/dist-server/service/tool-entity/create-service.js

@@ -0,0 +1,1053 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OperatoToolCreateService = void 0;
+const tslib_1 = require("tslib");
+const type_graphql_1 = require("type-graphql");
+const shell_1 = require("@things-factory/shell");
+const resource_base_1 = require("@things-factory/resource-base");
+const { camelCase, startCase, snakeCase, kebabCase } = require('lodash');
+const { plural } = require('pluralize');
+const fs = require('fs');
+let OperatoToolCreateService = class OperatoToolCreateService {
+    async toolCreateService(id, context) {
+        const { domain } = context.state;
+        // Entity 조회 
+        const entity = await (0, shell_1.getRepository)(resource_base_1.Entity).findOne({
+            where: {
+                id
+            }
+        });
+        // Entity 컬럼 조회 
+        const entityColumns = await (0, shell_1.getRepository)(resource_base_1.EntityColumn).find({
+            where: {
+                domain: { id: domain.id },
+                entity: { id: entity.id }
+            }
+        });
+        let { name = '', bundle = '' } = entity || {};
+        // 프로젝트 Root Path 구하기 
+        let appRootPath = this.getProjectRootPath();
+        let serviceName = 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, moduleName, name, serviceName, entity, entityColumns) {
+        // 이름 케이스 워드 만들기 
+        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, serviceName, entity, entityColumns, nameMap) {
+        // 서비스 연관 파일 생성 
+        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, serviceName, entity, entityColumns, nameMap) {
+        // 서비스 연관 파일 생성 
+        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) {
+        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 = this.getFieldType(column);
+            let colTxtType = 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 = this.getFieldType(column);
+            let colTxtType = 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, entityColumns) {
+        let entityText = serviceEntity;
+        // 컬럼 정렬
+        let sortedCols = entityColumns.sort(function (a, b) {
+            return a.rank - b.rank;
+        });
+        // 컬럼 정보 txt 변환 
+        let entityColsText = 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 = 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, entityColumns) {
+        let entityText = entity.dataProp == 'JSON' ? serviceEntityHistJson : serviceEntityHistCopy;
+        // 컬럼 정렬
+        let sortedCols = entityColumns.sort(function (a, b) {
+            return a.rank - b.rank;
+        });
+        // 컬럼 정보 txt 변환 
+        let entityColsText = 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) {
+        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 = 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 = '';
+        if (column.colType == 'string')
+            colSize = column.colSize;
+        let fieldType = this.getFieldType(column);
+        let colTxtType = 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) {
+        let fieldType = '';
+        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) {
+        let colTxtType = 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, fileText, nameMap) {
+        await fs.writeFileSync(filePath, this.replaceNamesMap(fileText, nameMap), 'utf8');
+    }
+    /**
+     * 문자열 치환
+     * @param text
+     * @param nameMap
+     * @returns
+     */
+    replaceNamesMap(text, nameMap) {
+        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, moduleName, serviceName) {
+        let path = 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 = process.env.PWD;
+        let splitPath = appPath.split('/');
+        let pathArr = [];
+        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) {
+        if (await this.existsPath(path) == false)
+            fs.mkdirSync(path);
+    }
+    /**
+     * Path 존재 여부
+     * @param path
+     * @returns
+     */
+    async existsPath(path) {
+        return await fs.existsSync(path);
+    }
+};
+tslib_1.__decorate([
+    (0, type_graphql_1.Query)(returns => Boolean, { description: 'Operato Tool Create Service' }),
+    tslib_1.__param(0, (0, type_graphql_1.Arg)('id')),
+    tslib_1.__param(1, (0, type_graphql_1.Ctx)()),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [String, Object]),
+    tslib_1.__metadata("design:returntype", Promise)
+], OperatoToolCreateService.prototype, "toolCreateService", null);
+OperatoToolCreateService = tslib_1.__decorate([
+    (0, type_graphql_1.Resolver)()
+], OperatoToolCreateService);
+exports.OperatoToolCreateService = OperatoToolCreateService;
+/* 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() 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() 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({ nullable: true })
+  creator?: User
+
+  @RelationId(({{camelCase name}}: {{pascalCase name}}) => {{camelCase name}}.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, {
+    createForeignKeyConstraints: false,
+    nullable: true
+  })
+  @Field({ 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'
+        : 'smallint',
+    enum: HistoryActionType
+  })
+  @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({ 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({ 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'
+        : 'smallint',
+    enum: HistoryActionType
+  })
+  @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({ 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({ 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;
+  }
+}
+`;
+//# sourceMappingURL=create-service.js.map