@notadd/cli/lib/commands/generate/util.ts

notadd core none dependence

import { join } from 'path';
import { readFileSync, writeFileSync, ensureFileSync, readJSONSync, pathExistsSync } from 'fs-extra';
import { upperFirst, } from "lodash";
import { Injectable } from "@notadd/core";
@Injectable()
export class UtilService {
    /**
     * 导入/导出/导入类名 的列表
     * @param {any[]} entities
     * @param {string} ext
     */
    importExportFileAndImportNames(entities: any[], ext: 'entity' | 'basic' | 'service' | 'api') {
        const upperExt = upperFirst(ext);
        const importFile = entities.map(it => {
            const name = it.entityName.replace(/Entity$/, `${upperExt == 'Api' ? 'ApiController' : upperExt}`);
            return `
import { ${name} } from './${it.fileName.replace('.entity.ts', `.${ext}`)}';`
        }).reduce((acc, cur) => (acc += cur), '');
        const exportFile = entities.map(it => {
            return `
export * from './${it.fileName.replace('.entity.ts', `.${ext}`)}';`
        }).reduce((acc, cur) => (acc += cur), '');
        const importNames = entities.map(it => {
            const name = it.entityName.replace(/Entity$/, `${upperExt == 'Api' ? 'ApiController' : upperExt}`);
            return `
        ${name},`
        }).reduce((acc, cur) => (acc += cur), '').trim();
        return { importFile, exportFile, importNames }
    }
    /**
     * 创建index.ts 并在本层导出
     * @param {string} dirName 文件夹名
     * @param {string} dirUrl 文件夹地址
     * @param {string} exportFile 导出文件列表(string)
     */
    createIndexTs(dirName: string, dirUrl: string, exportFile: string) {
        //创建此模块的index.ts
        const moduleIndex = `export * from './${dirName}.module';${exportFile}`;
        writeFileSync(join(dirUrl, `index.ts`), moduleIndex);
        // 本层的index.ts
        ensureFileSync(join(dirUrl, '../index.ts'));
        let thisIndex = readFileSync(join(dirUrl, '../index.ts')).toString();
        if (!thisIndex.includes(`${dirName}`)) {
            thisIndex += `
export * from './${dirName}';`;
            writeFileSync(join(dirUrl, '../index.ts'), thisIndex);
        }
    }
    /**
     * 获取所有层的package.json
     * @param {any[]} entities
     */
    getPackageJsons(entities: any[]):GetPackageJsonsResult {
        const dirName = entities[0].dirName;
        const libUrl = join(process.cwd(), '../../../')
        const basicDir = join(libUrl, './basic/src', dirName);
        const domainDir = join(libUrl, './domain/src', dirName);
        const entitiesDir = join(libUrl, './entities/src', dirName);
        const apiDir = join(libUrl, './api/src', dirName);
        // entity
        const entitiesPakcageJson = this._getPackageByLayerName('entities');
        // basic 
        const basicPakcageJson = this._getPackageByLayerName('basic');
        // domain
        const domainPakcageJson = this._getPackageByLayerName('domain')
        // api
        const apiPakcageJson = this._getPackageByLayerName('api');
        return { apiPakcageJson, domainPakcageJson, basicPakcageJson, entitiesPakcageJson, apiDir, entitiesDir, domainDir, basicDir };
    }
    private _getPackageByLayerName(layerName: 'entities' | 'basic' | 'domain' | 'api'): any {
        const packageUrl = join(process.cwd(), '../../../', layerName, 'package.json');
        if (!pathExistsSync(packageUrl)) throw new Error(`请创建${layerName}层package.json`)
        const pakcageJson = readJSONSync(packageUrl)
        if (!pakcageJson.name || !pakcageJson.version) throw new Error(`${layerName}层package.json没有name或version`);
        return pakcageJson;
    }

    
}
export  interface GetPackageJsonsResult{
    apiPakcageJson:any;
    domainPakcageJson:any;
    basicPakcageJson:any;
    entitiesPakcageJson:any;
    /**
     * @example "/root/.../api/src/test"
     */
    apiDir:string;
    entitiesDir:string;
    domainDir:string;
    basicDir:string;

}