@lakutata/cli 1.0.37 → 2.1.0-alpha.4

package/src/lib/generators/component/files/ComponentTestFile.ts

@@ -1,36 +0,0 @@
-import {ProjectSourceFile} from '../../project/ProjectSourceFile'
-import {SourceFile} from 'ts-morph'
-
-export class ComponentTestFile extends ProjectSourceFile {
-    readonly filePath: string
-    private readonly className: string
-
-    constructor(className: string) {
-        super()
-        this.className = className
-        this.filePath = `src/tests/${className}.test.spec.ts`
-    }
-
-    initSourceFile(file: SourceFile): SourceFile {
-        file.addImportDeclaration({namedImports: ['createApp'], moduleSpecifier: '@lakutata/core'})
-        file.addImportDeclaration({namedImports: [this.className], moduleSpecifier: `../${this.className}`})
-        file.addStatements(writer => {
-            writer.write(`
-            createApp({
-            id:'test.app',
-            name:'tester',
-            components:{
-            test:{
-            class:${this.className}
-            }
-            }
-            }).then(app=>{
-            const testComponent:${this.className} = app.Components.get<${this.className}>('test')
-            }).catch(e=>{
-            console.error(e)
-            })
-            `)
-        })
-        return file
-    }
-}

package/src/lib/generators/module/ModuleGenerator.ts

@@ -1,97 +0,0 @@
-import {IGenerator} from '../../../interfaces/IGenerator'
-import {IModuleInfo} from '../../../interfaces/IModuleInfo'
-import {ProjectGenerator} from '../project/ProjectGenerator'
-import {ModuleFile} from './files/ModuleFile'
-import {ModuleTestFile} from './files/ModuleTestFile'
-
-export class ModuleGenerator implements IGenerator {
-    private readonly projectPath: string
-    private readonly author: string
-    private readonly name: string
-    private readonly description: string
-    private readonly keywords: string | string[]
-    private readonly outputDir: string = 'distro'
-    private readonly sourceDir: string = 'src'
-    private readonly entryName: string
-    private readonly license: string
-    private readonly dependencies: { [name: string]: string }
-    private readonly devDependencies: { [name: string]: string }
-
-    constructor(options: IModuleInfo) {
-        this.projectPath = options.path
-        this.author = options.author
-        this.name = options.name
-        this.entryName = options.className
-        this.description = options.description ? options.description : 'No module description'
-        this.keywords = options.keywords ? options.keywords : []
-        this.license = options.license ? options.license : 'UNLICENSED'
-        this.dependencies = options.dependencies ? options.dependencies : {}
-        this.devDependencies = options.devDependencies ? options.devDependencies : {}
-    }
-
-    /**
-     * 生成模块项目
-     */
-    public async generate(): Promise<void> {
-        const testFile = new ModuleTestFile(this.entryName)
-        const projectGenerator = new ProjectGenerator({
-            entry: this.entryName,
-            projectDirectory: this.projectPath,
-            packageOptions: {
-                name: this.name,
-                author: this.author,
-                description: this.description,
-                keywords: this.keywords,
-                scripts: {},
-                license: this.license,
-                dependencies: this.dependencies,
-                devDependencies: this.dependencies,
-                addition: {
-                    lakutata: {
-                        type: 'module',
-                        directories: {
-                            threads: 'src/threads',
-                            processes: 'src/processes',
-                            modules: 'src/modules',
-                            components: 'src/components',
-                            plugins: 'src/plugins',
-                            exceptions: 'src/exceptions'
-                        }
-                    }
-                }
-            },
-            directories: [
-                'src/lib',
-                'src/exceptions',
-                'src/threads',
-                'src/processes',
-                'src/modules',
-                'src/components',
-                'src/plugins',
-                'src/tests'
-            ],
-            outputDir: this.outputDir,
-            sourceDir: this.sourceDir,
-            importLakutataCoreInDev: true,
-            files: [
-                new ModuleFile(this.entryName),
-                testFile
-            ],
-            testFile: testFile.filePath,
-            ignores: {
-                '.gitignore': [
-                    `${this.outputDir}`,
-                    ` ${this.outputDir}/*`,
-                    `./${this.outputDir}`,
-                    `/${this.outputDir}/`,
-                    `!${this.sourceDir}`
-                ],
-                '.npmignore': [
-                    `!./${this.outputDir}`,
-                    `./${this.sourceDir}`
-                ]
-            }
-        })
-        await projectGenerator.generate()
-    }
-}

package/src/lib/generators/module/files/ModuleFile.ts

@@ -1,116 +0,0 @@
-import {ProjectSourceFile} from '../../project/ProjectSourceFile'
-import {Scope, SourceFile, StructureKind} from 'ts-morph'
-
-export class ModuleFile extends ProjectSourceFile {
-    readonly filePath: string
-    private readonly className: string
-
-    constructor(className: string) {
-        super()
-        this.className = className
-        this.filePath = `src/${className}.ts`
-    }
-
-    initSourceFile(file: SourceFile): SourceFile {
-        file.addImportDeclaration({
-            namedImports: ['Module', 'Configurable', 'IComponentsConfig', 'IModulesConfig', 'TPluginsConfig', 'TProcessesConfig', 'TThreadsConfig', 'TWorkflowsConfig'],
-            moduleSpecifier: '@lakutata/core'
-        })
-        const moduleClass = file.addClass({
-            name: this.className,
-            extends: 'Module',
-            isExported: true
-        })
-        moduleClass.addMembers([
-            {
-                docs: [{
-                    kind: StructureKind.JSDoc,
-                    description: 'Module plugins'
-                }],
-                kind: StructureKind.Property,
-                name: 'plugins',
-                isReadonly: true,
-                scope: Scope.Protected,
-                type: 'TPluginsConfig',
-                initializer: '[]',
-                decorators: [{kind: StructureKind.Decorator, name: 'Configurable()'}]
-            },
-            {
-                docs: [{
-                    kind: StructureKind.JSDoc,
-                    description: 'Module components'
-                }],
-                kind: StructureKind.Property,
-                name: 'components',
-                isReadonly: true,
-                scope: Scope.Protected,
-                type: 'IComponentsConfig',
-                initializer: '{}',
-                decorators: [{kind: StructureKind.Decorator, name: 'Configurable()'}]
-            },
-            {
-                docs: [{
-                    kind: StructureKind.JSDoc,
-                    description: 'Subset modules'
-                }],
-                kind: StructureKind.Property,
-                name: 'modules',
-                isReadonly: true,
-                scope: Scope.Protected,
-                type: 'IModulesConfig',
-                initializer: '{}',
-                decorators: [{kind: StructureKind.Decorator, name: 'Configurable()'}]
-            },
-            {
-                docs: [{
-                    kind: StructureKind.JSDoc,
-                    description: 'Module threads'
-                }],
-                kind: StructureKind.Property,
-                name: 'threads',
-                isReadonly: true,
-                scope: Scope.Protected,
-                type: 'TThreadsConfig',
-                initializer: '[]',
-                decorators: [{kind: StructureKind.Decorator, name: 'Configurable()'}]
-            },
-            {
-                docs: [{
-                    kind: StructureKind.JSDoc,
-                    description: 'Module processes'
-                }],
-                kind: StructureKind.Property,
-                name: 'processes',
-                isReadonly: true,
-                scope: Scope.Protected,
-                type: 'TProcessesConfig',
-                initializer: '[]',
-                decorators: [{kind: StructureKind.Decorator, name: 'Configurable()'}]
-            },
-            {
-                docs: [{
-                    kind: StructureKind.JSDoc,
-                    description: 'Module workflows'
-                }],
-                kind: StructureKind.Property,
-                name: 'workflows',
-                isReadonly: true,
-                scope: Scope.Protected,
-                type: 'TWorkflowsConfig',
-                initializer: '[]',
-                decorators: [{kind: StructureKind.Decorator, name: 'Configurable()'}]
-            }
-        ])
-        const initMethod = moduleClass.addMethod({
-            name: 'initialize',
-            isAsync: true,
-            returnType: 'Promise<void>',
-            scope: Scope.Protected
-        })
-        initMethod.addStatements(writer => {
-            writer.writeLine(`//Initializer for ${this.className}`)
-            writer.writeLine(`//Write your module initialization codes here`)
-        })
-        return file
-    }
-}

package/src/lib/generators/module/files/ModuleTestFile.ts

@@ -1,36 +0,0 @@
-import {ProjectSourceFile} from '../../project/ProjectSourceFile'
-import {SourceFile} from 'ts-morph'
-
-export class ModuleTestFile extends ProjectSourceFile {
-    readonly filePath: string
-    private readonly className: string
-
-    constructor(className: string) {
-        super()
-        this.className = className
-        this.filePath = `src/tests/${className}.test.spec.ts`
-    }
-
-    initSourceFile(file: SourceFile): SourceFile {
-        file.addImportDeclaration({namedImports: ['createApp'], moduleSpecifier: '@lakutata/core'})
-        file.addImportDeclaration({namedImports: [this.className], moduleSpecifier: `../${this.className}`})
-        file.addStatements(writer => {
-            writer.write(`
-            createApp({
-            id:'test.app',
-            name:'tester',
-            modules:{
-            test:{
-            class:${this.className}
-            }
-            }
-            }).then(app=>{
-            const testModule:${this.className} = app.Modules.get<${this.className}>('test')
-            }).catch(e=>{
-            console.error(e)
-            })
-            `)
-        })
-        return file
-    }
-}

package/src/lib/generators/plugin/PluginGenerator.ts

@@ -1,87 +0,0 @@
-import {IGenerator} from '../../../interfaces/IGenerator'
-import {IPluginInfo} from '../../../interfaces/IPluginInfo'
-import {ProjectGenerator} from '../project/ProjectGenerator'
-import {PluginFile} from './files/PluginFile'
-import {PluginTestFile} from './files/PluginTestFile'
-
-export class PluginGenerator implements IGenerator {
-    private readonly projectPath: string
-    private readonly author: string
-    private readonly name: string
-    private readonly description: string
-    private readonly keywords: string | string[]
-    private readonly outputDir: string = 'distro'
-    private readonly sourceDir: string = 'src'
-    private readonly entryName: string
-    private readonly license: string
-    private readonly dependencies: { [name: string]: string }
-    private readonly devDependencies: { [name: string]: string }
-
-    constructor(options: IPluginInfo) {
-        this.projectPath = options.path
-        this.author = options.author
-        this.name = options.name
-        this.entryName = options.className
-        this.description = options.description ? options.description : 'No plugin description'
-        this.keywords = options.keywords ? options.keywords : []
-        this.license = options.license ? options.license : 'UNLICENSED'
-        this.dependencies = options.dependencies ? options.dependencies : {}
-        this.devDependencies = options.devDependencies ? options.devDependencies : {}
-    }
-
-    /**
-     * 生成插件项目
-     */
-    public async generate(): Promise<void> {
-        const testFile = new PluginTestFile(this.entryName)
-        const projectGenerator = new ProjectGenerator({
-            entry: this.entryName,
-            projectDirectory: this.projectPath,
-            packageOptions: {
-                name: this.name,
-                author: this.author,
-                description: this.description,
-                keywords: this.keywords,
-                scripts: {},
-                license: this.license,
-                dependencies: this.dependencies,
-                devDependencies: this.dependencies,
-                addition: {
-                    lakutata: {
-                        type: 'plugin',
-                        directories: {
-                            exceptions: 'src/exceptions'
-                        }
-                    }
-                }
-            },
-            directories: [
-                'src/lib',
-                'src/exceptions',
-                'src/tests'
-            ],
-            outputDir: this.outputDir,
-            sourceDir: this.sourceDir,
-            importLakutataCoreInDev: true,
-            files: [
-                new PluginFile(this.entryName),
-                testFile
-            ],
-            testFile: testFile.filePath,
-            ignores: {
-                '.gitignore': [
-                    `${this.outputDir}`,
-                    ` ${this.outputDir}/*`,
-                    `./${this.outputDir}`,
-                    `/${this.outputDir}/`,
-                    `!${this.sourceDir}`
-                ],
-                '.npmignore': [
-                    `!./${this.outputDir}`,
-                    `./${this.sourceDir}`
-                ]
-            }
-        })
-        await projectGenerator.generate()
-    }
-}

package/src/lib/generators/plugin/files/PluginFile.ts

@@ -1,50 +0,0 @@
-import {ProjectSourceFile} from '../../project/ProjectSourceFile'
-import {ModuleDeclarationKind, Scope, SourceFile, StructureKind} from 'ts-morph'
-
-export class PluginFile extends ProjectSourceFile {
-    readonly filePath: string
-    private readonly className: string
-
-    constructor(className: string) {
-        super()
-        this.className = className
-        this.filePath = `src/${className}.ts`
-    }
-
-    initSourceFile(file: SourceFile): SourceFile {
-        file.addImportDeclaration({
-            namedImports: ['Plugin', 'Configurable'],
-            moduleSpecifier: '@lakutata/core'
-        })
-        file.addStatements([{
-            declarationKind: ModuleDeclarationKind.Module,
-            kind: StructureKind.Module,
-            hasDeclareKeyword: true,
-            name: `'@lakutata/core'`,
-            statements: [{
-                kind: StructureKind.Interface,
-                name: 'Application',
-                properties: [{
-                    name: this.className,
-                    type: this.className
-                }]
-            }]
-        }])
-        const pluginClass = file.addClass({
-            name: this.className,
-            extends: 'Plugin',
-            isExported: true
-        })
-        const onActivationMethod = pluginClass.addMethod({
-            name: 'onActivation',
-            isAsync: false,
-            returnType: 'void',
-            scope: Scope.Protected
-        })
-        onActivationMethod.addStatements(writer => {
-            writer.writeLine('//Codes in here will be executed on plugin activation')
-            writer.writeLine('//Plugin is always executed in transient mode')
-        })
-        return file
-    }
-}

package/src/lib/generators/plugin/files/PluginTestFile.ts

@@ -1,36 +0,0 @@
-import {ProjectSourceFile} from '../../project/ProjectSourceFile'
-import {SourceFile} from 'ts-morph'
-
-export class PluginTestFile extends ProjectSourceFile {
-    readonly filePath: string
-    private readonly className: string
-
-    constructor(className: string) {
-        super()
-        this.className = className
-        this.filePath = `src/tests/${className}.test.spec.ts`
-    }
-
-    initSourceFile(file: SourceFile): SourceFile {
-        file.addImportDeclaration({namedImports: ['createApp'], moduleSpecifier: '@lakutata/core'})
-        file.addImportDeclaration({namedImports: [this.className], moduleSpecifier: `../${this.className}`})
-        file.addStatements(writer => {
-            writer.write(`
-            createApp({
-            id:'test.app',
-            name:'tester',
-            plugins:[
-            {
-            class:${this.className}
-            }
-            ]
-            }).then(app=>{
-            const testComponent:${this.className} = app.${this.className}
-            }).catch(e=>{
-            console.error(e)
-            })
-            `)
-        })
-        return file
-    }
-}

package/src/lib/generators/project/ProjectGenerator.ts

@@ -1,205 +0,0 @@
-import {Project, ts} from 'ts-morph'
-import path from 'path'
-import {ProjectTypescriptConfig} from './configs/ProjectTypescriptConfig'
-import {ProjectPackageConfig} from './configs/ProjectPackageConfig'
-import {IPreparePackageConfigOptions} from '../../../interfaces/IPreparePackageConfigOptions'
-import {ProjectEslintrcConfig} from './configs/ProjectEslintrcConfig'
-import simpleGit, {GitError, RemoteWithRefs, SimpleGit, SimpleGitTaskCallback} from 'simple-git'
-import {IProjectGeneratorOptions} from '../../../interfaces/IProjectGeneratorOptions'
-import {IGenerator} from '../../../interfaces/IGenerator'
-import {GitIgnore} from '../../../constants/GitIgnore'
-import {ProjectSourceFile} from './ProjectSourceFile'
-import { LatestVersion } from '../../LatestVersion'
-
-export class ProjectGenerator implements IGenerator {
-    private readonly project: Project
-    private readonly projectDir: string
-    private readonly packageOptions: IPreparePackageConfigOptions
-    private readonly projectEntryPoint: string
-    private readonly sourceDir: string
-    private readonly outputDir: string
-    private readonly importLakutataCoreInDev: boolean
-    private readonly directories: string[]
-    private readonly files: ProjectSourceFile[]
-    private readonly ignores: { [ignoreName: string]: string[] }
-    private readonly lakutataPackageName: string = '@lakutata/core'
-    private readonly testFilePath: string
-    private lakutataCoreVersion: string
-
-    constructor(options: IProjectGeneratorOptions) {
-        this.project = new Project()
-        this.projectDir = options.projectDirectory
-        this.projectEntryPoint = options.entry
-        this.packageOptions = options.packageOptions
-        this.files = options.files
-        this.testFilePath = options.testFile
-        this.directories = options.directories ? options.directories : []
-        this.sourceDir = options.sourceDir ? options.sourceDir : 'src'
-        this.outputDir = options.outputDir ? options.outputDir : 'build'
-        this.ignores = {'.gitignore': GitIgnore}
-        if (options.ignores) {
-            for (const filename of Object.keys(options.ignores)) {
-                if (this.ignores[filename]) {
-                    this.ignores[filename] = this.ignores[filename].concat(options.ignores[filename])
-                } else {
-                    this.ignores[filename] = options.ignores[filename]
-                }
-            }
-        }
-        this.importLakutataCoreInDev = !!options.importLakutataCoreInDev
-    }
-
-    /**
-     * 检查框架最新版本
-     * @private
-     */
-    private async checkLatestFrameworkVersion(): Promise<void> {
-        this.lakutataCoreVersion = await LatestVersion(this.lakutataPackageName)
-    }
-
-    /**
-     * 获取git仓库地址
-     * @private
-     */
-    private async getGitRepository(): Promise<string | null> {
-        try {
-            const git: SimpleGit = simpleGit({
-                baseDir: this.projectDir,
-                binary: 'git'
-            })
-            return new Promise<string | null>(resolve => {
-                const callback: SimpleGitTaskCallback & any = function <E extends GitError = GitError>(err: E, data: RemoteWithRefs[]) {
-                    if (err) {
-                        resolve(null)
-                    } else {
-                        data.forEach(repo => {
-                            if (repo.name === 'origin' && repo.refs) {
-                                resolve(repo.refs.push)
-                            }
-                        })
-                        resolve(null)
-                    }
-                }
-                git.getRemotes(true, callback)
-            })
-        } catch (e) {
-            return null
-        }
-    }
-
-    /**
-     * 生成tsconfig.json
-     * @protected
-     */
-    protected prepareTypescriptConfig(): void {
-        const tsConfig = ProjectTypescriptConfig
-        tsConfig.compilerOptions.outDir = this.outputDir
-        tsConfig.compilerOptions.rootDir = this.sourceDir
-        this.project.createSourceFile(path.resolve(this.projectDir, 'tsconfig.json'), JSON.stringify(ProjectTypescriptConfig, null, 2))
-    }
-
-    /**
-     * 生成package.json
-     * @protected
-     */
-    protected async preparePackageConfig(): Promise<void> {
-        const options: IPreparePackageConfigOptions = this.packageOptions
-        const addition = options.addition ? options.addition : {}
-        const packageConfig = Object.assign(ProjectPackageConfig, addition)
-        packageConfig.name = options.name
-        packageConfig.author = options.author
-        packageConfig.main = `./${this.outputDir}/${this.projectEntryPoint}.js`
-        packageConfig.types = `./${this.outputDir}/${this.projectEntryPoint}.d.ts`
-        packageConfig.description = options.description ? options.description : 'No description'
-        packageConfig.scripts = {
-            lakutata: 'node ./node_modules/@lakutata/cli',
-            clean: `shx rm -rf ./${this.outputDir}`,
-            build: `tsc`,
-            rebuild: `npm run clean && npm run build`,
-            prepare: `npm run compile`,
-            compile: `npm run rebuild && shx rm -rf ./${this.outputDir}/tests/*`,
-            test: `node -r ./node_modules/ts-node/register ${this.testFilePath}`
-        }
-        packageConfig.scripts = options.scripts ? Object.assign(packageConfig.scripts, options.scripts) : packageConfig.scripts
-        packageConfig.dependencies = options.dependencies ? Object.assign(packageConfig.dependencies, options.dependencies) : packageConfig.dependencies
-        packageConfig.devDependencies = Object.assign(options.devDependencies ? Object.assign(packageConfig.devDependencies, options.devDependencies) : packageConfig.devDependencies, {
-            '@lakutata/cli': await LatestVersion('@lakutata/cli')
-        })
-        const gitRepository: string | null = await this.getGitRepository()
-        if (gitRepository) {
-            packageConfig.repository = {
-                type: 'git',
-                url: gitRepository
-            }
-        }
-        if (this.importLakutataCoreInDev) {
-            packageConfig.devDependencies[this.lakutataPackageName] = `^${this.lakutataCoreVersion}`
-        } else {
-            packageConfig.dependencies[this.lakutataPackageName] = `^${this.lakutataCoreVersion}`
-        }
-        packageConfig.keywords = options.keywords ? Array.isArray(options.keywords) ? options.keywords : [options.keywords] : ['lakutata']
-        packageConfig.license = options.license ? options.license : 'UNLICENSED'
-        this.project.createSourceFile(path.resolve(this.projectDir, 'package.json'), JSON.stringify(packageConfig, null, 2))
-    }
-
-    /**
-     * 生成.eslintrc.json
-     * @protected
-     */
-    protected prepareEslintConfig(): void {
-        this.project.createSourceFile(path.resolve(this.projectDir, '.eslintrc.json'), JSON.stringify(ProjectEslintrcConfig, null, 2))
-    }
-
-    /**
-     * 生成文件夹
-     * @protected
-     */
-    protected prepareDirectories(): void {
-        this.directories.forEach(dirPath => {
-            this.project.createDirectory(path.resolve(this.projectDir, dirPath))
-            this.project.createSourceFile(path.resolve(this.projectDir, dirPath, './.gitkeep'))
-        })
-    }
-
-    /**
-     * 生成文件
-     */
-    public prepareFiles() {
-        this.files.forEach(projectSourceFile => {
-            projectSourceFile.initSourceFile(this.project.createSourceFile(path.resolve(this.projectDir, projectSourceFile.filePath)))
-                .formatText({
-                    indentStyle: ts.IndentStyle.Block,
-                    ensureNewLineAtEndOfFile: true,
-                    semicolons: ts.SemicolonPreference.Remove
-                })
-        })
-    }
-
-    /**
-     * 生成.ignore文件
-     */
-    public prepareIgnores() {
-        for (const filename of Object.keys(this.ignores)) {
-            this.project.createSourceFile(path.resolve(this.projectDir, filename), writer => {
-                this.ignores[filename].forEach(value => {
-                    writer.writeLine(value)
-                })
-            })
-        }
-    }
-
-    /**
-     * 生成项目
-     */
-    public async generate(): Promise<void> {
-        await this.checkLatestFrameworkVersion()
-        this.project.createDirectory(this.projectDir)
-        await this.preparePackageConfig()
-        this.prepareTypescriptConfig()
-        this.prepareEslintConfig()
-        this.prepareDirectories()
-        this.prepareFiles()
-        this.prepareIgnores()
-        await this.project.save()
-    }
-}

package/src/lib/generators/project/ProjectSourceFile.ts

@@ -1,7 +0,0 @@
-import {SourceFile} from 'ts-morph'
-
-export abstract class ProjectSourceFile {
-    public abstract readonly filePath: string
-
-    public abstract initSourceFile(file: SourceFile): SourceFile
-}