@notadd/cli/lib/commands/create.ts

notadd core none dependence

import { Command } from "@notadd/cli-core";
import { Controller, Param, Logger, Query, Args } from '@notadd/core';
import { writeFileSync, existsSync } from 'fs-extra'
import { join } from 'path'
const toPascalCase = (str: string) => str.split('-').reduce((res, part) => res + part[0].toUpperCase() + part.substr(1), '');
/**
 * 生成命令
 */
@Controller()
export class CreateCommand {
    constructor(private logger: Logger) { }
    /**
     * 自动生成组件模板
     * @param name 
     */
    @Command('cp/:name')
    async createComponent(@Param('name') name: string) {
        if (!name) {
            this.logger.log(`name参数不能为空`)
            return;
        }
        const template = `import { Module } from '@notadd/core';
@Module({
    providers: [],
    imports: [],
    controllers: []
})
export class ${toPascalCase(name)}Module {
    
}
`
        const path = join(process.cwd(), `${name}.module.ts`)
        if (existsSync(path)) {
            this.logger.log(`文件已存在:${path}`)
        } else {
            writeFileSync(path, template)
        }
    }
    /**
     * 自动生成module模板
     * @param name 
     * notadd cm/demoModule?i=2 --name2=demo2
     */
    @Command('cm/:path')
    async createModule(@Param('path') name: string, @Args('name2') name2: string) {
        if (!name) {
            this.logger.log(`name参数不能为空`)
            return;
        }
        const template = `import { Module } from '@notadd/core';
@Module({
    providers: [],
    imports: [],
    controllers: []
})
export class ${toPascalCase(name)}Module {
    
}
`
        const path = join(process.cwd(), `${name}.module.ts`)
        if (existsSync(path)) {
            this.logger.log(`文件已存在:${path}`)
        } else {
            writeFileSync(path, template)
        }
    }
    /**
     * 自动生成service模板
     * @param name 
     */
    @Command(`cs/:name`)
    async createService(@Param('name') name: string) {
        if (!name) {
            this.logger.log(`name参数不能为空`)
            return;
        }
        const template = `import { Injectable } from '@notadd/core';
@Injectable()
export class ${toPascalCase(name)}Service {
    
}
`
        const path = join(process.cwd(), `${name}.service.ts`)
        if (existsSync(path)) {
            this.logger.log(`文件已存在:${path}`)
        } else {
            writeFileSync(path, template)
        }
    }
    /**
     * 自动生成Entity模板
     * @param name 
     */
    @Command('ce/:name')
    async createEntity(@Param('name') name: string) {
        if (!name) {
            this.logger.log(`name参数不能为空`)
            return;
        }
        const template = `import { Entity, PrimaryGeneratedColumn } from '@notadd/typeorm';
@Entity()
export class ${toPascalCase(name)}Entity {
    @PrimaryGeneratedColumn()
    id: number;
}
`
        const path = join(process.cwd(), `${name}.entity.ts`)
        if (existsSync(path)) {
            this.logger.log(`文件已存在:${path}`)
        } else {
            writeFileSync(path, template)
        }
    }
    /**
     * 自动生成controller模板
     * @param name 
     */
    @Command('cc/:name')
    async createController(@Param('name') name: string) {
        if (!name) {
            this.logger.log(`name参数不能为空`)
            return;
        }
        const template = `import { Controller, Query, Args, EntityService } from '@notadd/core';
@Controller()
export class ${toPascalCase(name)}Controller {
    constructor(private entityService: EntityService ){}
    @Query()
    async ${name}(@Args('entity') entity: ${toPascalCase(name)}Input): Promise<${toPascalCase(name)}Output> {
        return {} as ${toPascalCase(name)}Output;
    }
}
export interface ${toPascalCase(name)}Input {

}
export interface ${toPascalCase(name)}Output {

}
`

        const path = join(process.cwd(), `${name}.controller.ts`)
        if (existsSync(path)) {
            this.logger.log(`文件已存在:${path}`)
        } else {
            writeFileSync(path, template)
        }
    }
}