@notadd/cli/lib/commands/generate/createApi.js

notadd core none dependence

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.CreateApiService = void 0;
const tslib_1 = require("tslib");
const path_1 = require("path");
const fs_extra_1 = require("fs-extra");
const lodash_1 = require("lodash");
const util_1 = require("./util");
const core_1 = require("@notadd/core");
let CreateApiService = class CreateApiService {
    constructor(util) {
        this.util = util;
    }
    createApi(entities) {
        const dirName = entities[0].dirName;
        // 获取不同层的package.json
        this._packageJsons = this.util.getPackageJsons(entities);
        const { apiDir } = this._packageJsons;
        fs_extra_1.ensureDirSync(apiDir);
        //创建api文件
        entities.forEach((it) => {
            const { entityFileName } = this._entityFormat(it);
            const addContent = this._createAddContent(it);
            if (!fs_extra_1.pathExistsSync(apiDir + `/${entityFileName}-add.api.ts`)) {
                fs_extra_1.writeFileSync(apiDir + `/${entityFileName}-add.api.ts`, addContent);
            }
            const listContent = this._createListContent(it);
            if (!fs_extra_1.pathExistsSync(apiDir + `/${entityFileName}-list.api.ts`)) {
                fs_extra_1.writeFileSync(apiDir + `/${entityFileName}-list.api.ts`, listContent);
            }
            const updateContent = this._createUpdateContent(it);
            if (!fs_extra_1.pathExistsSync(apiDir + `/${entityFileName}-update.api.ts`)) {
                fs_extra_1.writeFileSync(apiDir + `/${entityFileName}-update.api.ts`, updateContent);
            }
            const deleteContent = this._createDeleteContent(it);
            if (!fs_extra_1.pathExistsSync(apiDir + `/${entityFileName}-delete.api.ts`)) {
                fs_extra_1.writeFileSync(apiDir + `/${entityFileName}-delete.api.ts`, deleteContent);
            }
            const detailContent = this._createDetailContent(it);
            if (!fs_extra_1.pathExistsSync(apiDir + `/${entityFileName}-detail.api.ts`)) {
                fs_extra_1.writeFileSync(apiDir + `/${entityFileName}-detail.api.ts`, detailContent);
            }
        });
        // 导入文件 导入文件名 导出文件
        const imports = this._createApiImports(entities);
        // 创建.module.ts
        const moduleContent = this._createModuleContent(entities, imports);
        const apiModuleName = `${dirName}.module.ts`;
        const apiModuleUrl = path_1.join(apiDir, apiModuleName);
        if (fs_extra_1.pathExistsSync(apiModuleUrl)) {
            console.log(`api层已存在${apiModuleName}文件，所以未生成`);
        }
        else {
            fs_extra_1.writeFileSync(apiModuleUrl, moduleContent);
        }
        //创建此模块的index.ts 和修改模块的导出
        this.util.createIndexTs(dirName, apiDir, imports.exportFile);
    }
    _createAddContent(it) {
        const { pickList, domainName, usedEntity, entityPre, addName } = this._entityFormat(it);
        const { entitiesPakcageJson, domainPakcageJson } = this._packageJsons;
        return `
import { Mutation } from '@notadd/graphql';
import { Args, Controller, EntityService } from '@notadd/core';
import { ClassValidatorService } from '@notadd/class-validator';
import { GraphqlError, TypeError } from '@ganker/error';
import { ${domainName} } from '${domainPakcageJson.name}';
import { ${it.entityName} } from '${entitiesPakcageJson.name}';
export type ${entityPre}AddInput = Pick<
    ${it.entityName}, ${pickList}
>;

@Controller()
export class ${addName} {
    constructor(
        private readonly entityService: EntityService,
        private readonly validator: ClassValidatorService,
        private readonly ${usedEntity}: ${domainName}
    ) {}
    /**
     * 添加
     */
    @Mutation()
    async ${usedEntity}Add(
        @Args('entity') entity: ${entityPre}AddInput
    ): Promise<any> {
        try {
            const created = await this.entityService.createType(${it.entityName}, entity);
            const errMessage = await this.validator.validateOrMessage(created, ${it.entityName});
            if (errMessage) throw new TypeError('02', errMessage);
            return await this.${usedEntity}.add(created);
        } catch (e) {
            throw new GraphqlError(\`B200101\${e.code}\`, e.message);
        }
    }
}
`;
    }
    _createListContent(it) {
        const { pickList, domainName, usedEntity, entityPre, listName } = this._entityFormat(it);
        const { entitiesPakcageJson, domainPakcageJson } = this._packageJsons;
        return `
import { Query, Limit, ListCount } from '@notadd/graphql';
import { Args, Controller } from '@notadd/core';
import { GraphqlError } from '@ganker/error';
import { ${domainName} } from '${domainPakcageJson.name}';
import { ${it.entityName} } from '${entitiesPakcageJson.name}';
interface ${entityPre}ListInputWhere {
    ids?: number[]
}
interface ${entityPre}ListInputOrder {
    createDate?: string;
}
type ${entityPre}ListResult = Partial<
    Pick<
        ${it.entityName}, ${pickList}
    >
>;

@Controller()
export class ${listName} {
    constructor(private readonly ${usedEntity}: ${domainName}) {}
    /**
     * 列表
     */
    @Query()
    async ${usedEntity}List(
        @Args('where') where?: ${entityPre}ListInputWhere,
        @Args('limit') limit?: Limit,
        @Args('order') order?: ${entityPre}ListInputOrder
    ): Promise<ListCount<${entityPre}ListResult>> {
        try {
            return await this.${usedEntity}.list(where, limit, order);
        } catch (e) {
            throw new GraphqlError(\`B200103\${e.code}\`, e.message);
        }
    }
}
`;
    }
    _createUpdateContent(it) {
        const { pickList, domainName, usedEntity, entityPre, updateName } = this._entityFormat(it);
        const { entitiesPakcageJson, domainPakcageJson } = this._packageJsons;
        return `
import { Mutation } from '@notadd/graphql';
import { Args, Controller } from '@notadd/core';
import { ClassValidatorService } from '@notadd/class-validator';
import { GraphqlError, TypeError } from '@ganker/error';
import { ${domainName} } from '${domainPakcageJson.name}';
import { ${it.entityName} } from '${entitiesPakcageJson.name}';
type ${entityPre}UpdateInputEntity = Partial<
    Pick<
        ${it.entityName}, ${pickList}
    >
>;
@Controller()
export class ${updateName} {
    constructor(
        private readonly validator: ClassValidatorService,
        private readonly ${usedEntity}: ${domainName}
        ) {}
    /**
     * 修改
     */
    @Mutation()
    async ${usedEntity}UpdateById(
        @Args('id') id: number,
        @Args('entity') entity: ${entityPre}UpdateInputEntity
    ): Promise<any> {
        try {
            const errMessage = await this.validator.validateOrMessage(entity, ${it.entityName}, {
                skipMissingProperties: true,
            });
            if (errMessage) throw new TypeError('02', errMessage);
            return await this.${usedEntity}.updateById(id, entity);
        } catch (e) {
            throw new GraphqlError(\`B200104\${e.code}\`, e.message);
        }
    }
}
`;
    }
    _createDeleteContent(it) {
        const { domainName, usedEntity, deleteName } = this._entityFormat(it);
        const { domainPakcageJson } = this._packageJsons;
        return `
        import { Mutation } from '@notadd/graphql';
        import { Args, Controller } from '@notadd/core';
        import { GraphqlError } from '@ganker/error';
        import { ${domainName} } from '${domainPakcageJson.name}';
        @Controller()
        export class ${deleteName} {
            constructor(private readonly ${usedEntity}: ${domainName}) {}
            /**
             * 删除
             */
            @Mutation()
            async ${usedEntity}DeleteById(@Args('id') id: number): Promise<any> {
                try {
                    return await this.${usedEntity}.deleteById(id);
                } catch (e) {
                    throw new GraphqlError(\`B200102\${e.code}\`, e.message);
                }
            }
        }
        `;
    }
    _createDetailContent(it) {
        const { domainName, usedEntity, detailName } = this._entityFormat(it);
        const { entitiesPakcageJson, domainPakcageJson } = this._packageJsons;
        return `
        import { Query } from '@notadd/graphql';
        import { Args, Controller } from '@notadd/core';
        import { GraphqlError } from '@ganker/error';
        import { ${domainName} } from '${domainPakcageJson.name}';
        import { ${it.entityName} } from '${entitiesPakcageJson.name}';
        @Controller()
        export class ${detailName} {
            constructor(private readonly ${usedEntity}: ${domainName}) {}
            /**
             * 详情
             */
            @Query()
            async ${usedEntity}DetailById(
                @Args('id') id: number
            ): Promise<${it.entityName}> {
                try {
                    return await this.${usedEntity}.detailById(id);
                } catch (e) {
                    throw new GraphqlError(\`B200105\${e.code}\`, e.message);
                }
            }
        }
        `;
    }
    _createModuleContent(entities, imports) {
        const dirName = entities[0].dirName;
        const { domainPakcageJson } = this._packageJsons;
        return `
import { Module } from '@notadd/core';
import { ClassValidatorModule } from '@notadd/class-validator';
import { ${lodash_1.upperFirst(dirName)}DomainModule } from '${domainPakcageJson.name}';${imports.importFile}
@Module({
   imports: [
        ${lodash_1.upperFirst(dirName)}DomainModule,
        ClassValidatorModule,
    ],
    controllers: [
        ${imports.importNames}
    ]
})
export class ${lodash_1.upperFirst(dirName)}ApiModule {}
   `;
    }
    _createApiImports(entities) {
        // 导入文件 导入文件名 导出文件
        return entities
            .map((it) => {
            const { entityFileName, listName, updateName, deleteName, detailName, addName, } = this._entityFormat(it);
            // 导入文件
            const importFile = `
import { ${addName} } from './${entityFileName}-add.api';
import { ${listName} } from './${entityFileName}-list.api';
import { ${updateName} } from './${entityFileName}-update.api';
import { ${deleteName} } from './${entityFileName}-delete.api';
import { ${detailName} } from './${entityFileName}-detail.api';`;
            // 导入文件名
            const importNames = `${addName},
    	${listName},
    	${updateName},
    	${deleteName},
    	${detailName},
    	`;
            // 导出文件
            const exportFile = `
export * from './${entityFileName}-add.api';
export * from './${entityFileName}-list.api';
export * from './${entityFileName}-update.api';
export * from './${entityFileName}-delete.api';
export * from './${entityFileName}-detail.api';`;
            return { importFile, importNames, exportFile };
        })
            .reduce((acc, cur) => {
            acc.importFile += cur.importFile;
            acc.importNames += cur.importNames;
            acc.exportFile += cur.exportFile;
            return acc;
        }, { importFile: '', importNames: ``, exportFile: `` });
    }
    _entityFormat(it) {
        const filedNames = it.filedNames;
        const pickList = filedNames
            .map((filed, filedIndex) => {
            if (filedIndex == filedNames.length - 1) {
                return `'${filed}'`;
            }
            return `'${filed}' | `;
        })
            .reduce((acc, cur) => (acc += cur), '');
        const entityFileName = it.fileName.replace('.entity.ts', '');
        const domainName = it.entityName.replace(/Entity$/, 'Service');
        const usedEntity = lodash_1.lowerFirst(it.entityName.replace(/Entity$/, ''));
        const entityPre = it.entityName.replace(/Entity$/, '');
        const addName = it.entityName.replace(/Entity$/, 'AddApiController');
        const listName = it.entityName.replace(/Entity$/, 'ListApiController');
        const updateName = it.entityName.replace(/Entity$/, 'UpdateApiController');
        const deleteName = it.entityName.replace(/Entity$/, 'DeleteApiController');
        const detailName = it.entityName.replace(/Entity$/, 'DetailApiController');
        return {
            pickList,
            entityFileName,
            domainName,
            usedEntity,
            entityPre,
            listName,
            updateName,
            deleteName,
            detailName,
            addName,
        };
    }
};
CreateApiService = tslib_1.__decorate([
    core_1.Injectable(),
    tslib_1.__metadata("design:paramtypes", [util_1.UtilService])
], CreateApiService);
exports.CreateApiService = CreateApiService;