@celljs/cli 3.0.0

package/src/cell.ts

@@ -0,0 +1,214 @@
+const leven = require('leven');
+import * as ora from 'ora';
+import { HookExecutor, HookStage } from '@celljs/cli-common/lib/hook/hook-executor';
+import { CommandUtil } from '@celljs/cli-common/lib/utils/command-util';
+import { program, Command } from '@celljs/cli-common/lib/command/command-protocol';
+import { BannerUtil } from './utils/banner-util';
+import build from './build/build';
+import serve from './serve/serve';
+import deploy from './deploy/deploy';
+const chalk = require('chalk');
+const updateNotifier = require('update-notifier');
+const pkg = require('../package.json');
+
+const version = pkg.version;
+updateNotifier({ pkg }).notify();
+
+const spinner = ora({ text: chalk.italic.gray('loading command line context...\n'), discardStdin: false });
+
+(async () => {
+    const { runtime, framework, settings } = JSON.parse(process.env.MALAGU_RFS!);
+    BannerUtil.print(version, settings, runtime, framework);
+
+    spinner.start();
+    const context = await CommandUtil.loadContext(settings, framework, runtime, undefined, spinner);
+    await new HookExecutor().executeHooks(context, 'cliHooks', HookStage.before);
+    const { componentPackages, configHookModules, webpackHookModules, serveHookModules, buildHookModules, deployHookModules, infoHookModules, propsHookModules } = context.pkg;
+
+    if (CommandUtil.includesCommand(context.args, settings.compileCommands)) {
+        process.send!({
+            type: 'cliContext',
+            data: {
+                components: componentPackages.map(c => c.cellComponent),
+                configHookModules,
+                webpackHookModules,
+                serveHookModules,
+                buildHookModules,
+                deployHookModules,
+                infoHookModules,
+                propsHookModules
+            }
+        });
+    }
+
+    program
+        .version(version, '-V, --version', 'version for cell')
+        .option('-t, --targets [targets]', 'targets for cell', value => value ? value.split(',') : [])
+        .option('-m, --mode [mode]', 'mode for cell', value => value ? value.split(',') : [])
+        .option('--props-dir [propsDir]', 'props directory for cell')
+        .option('--props-file [propsFile]', 'props file for cell')
+        .option('--skip-auto-install [skipAutoInstall]', 'skip automatic installation of components for cell')
+        .usage('<command> [options]');
+
+    program
+        .command('init [template]')
+        .option('-o, --output-dir [path]', 'output directory')
+        .option('-p --packager [packager]', 'package manager(pnpm, yarn, npm)')
+        .description('init a application')
+        .action((template, options) => {
+            require('./init/init').default({ template, ...options });
+        });
+
+    program
+        .command('serve')
+        .option('-p, --port [port]', 'port used by the server')
+        .description('serve a applicaton')
+        .action((entry, options) => {
+            serve(context, { entry, ...options });
+        });
+
+    program
+        .command('build')
+        .description('build a application')
+        .action((entry, options) => {
+            build(context, { entry, ...options });
+        });
+
+    program
+        .command('deploy')
+        .option('-s, --skip-build [skipBuild]', 'skip the build process')
+        .description('deploy a applicaton')
+        .action((entry, options) => {
+            deploy(context, { entry, ...options });
+        });
+
+    program
+        .command('props')
+        .description('display properties about application')
+        .option('-n, --name [name]', 'get the property value of the specified name')
+        .option('-f, --frontend [frontend]', 'frontend properties')
+        .option('-b, --backend [backend]', 'backend properties')
+        .action(options => {
+            require('./props/props').default(context, { ...options });
+        });
+    program
+        .command('info')
+        .description('display information about application')
+        .action(options => {
+            require('./info/info').default(context, { ...options });
+        });
+
+    program
+        .command('config')
+        .option('--default-runtime [defaultRuntime]', 'default runtime')
+        .option('--default-mode [defaultMode]', 'default mode', value => value ? value.split(',') : [])
+        .option('--frameworks-url [frameworksUrl]', 'frameworks url')
+        .option('--frameworks-upstream-url [frameworksUpStreamUrl]', 'frameworks upstream url')
+        .option('--config-file-alias [configFileAlias]', 'config file alias')
+        .option('--show [show]', 'show properties for the application')
+        .description('configure properties for the application')
+        .action(options => {
+            require('./config/config').default(context, { ...options });
+        });
+
+    program
+        .command('update')
+        .option('-v, --version [version]', 'version for cell')
+        .option('-d, --dist-tag [distTag]', 'Which dist-tag to use to find the latest version')
+        .option('-s, --skip-installing-component [skipIntallingComponent]', 'skip installing components')
+        .description('update cell cli and current project\'s cell components')
+        .action(options => {
+            require('./update/update').default(context, { ...options });
+        });
+
+    const runtimeCmd = program
+        .command('runtime [command]')
+        .alias('r')
+        .description('management runtime');
+    runtimeCmd
+        .command('install [runtime] [alias]')
+        .alias('i')
+        .description('install a runtime')
+        .option('-f, --force-installing-component [forceInstallingComponent]', 'force installing component')
+        .option('-o, --overwrite [overwrite]', 'overwrite existing runtime')
+        .option('-v, --version [version]', 'specify runtime version', 'latest')
+        .action((r, alias, options) => {
+            require('@celljs/cli-runtime/lib/install/install').default({ runtime: r, alias, ...options });
+        });
+    runtimeCmd
+        .command('use [runtime]')
+        .description('use a runtime')
+        .action(r => {
+            require('@celljs/cli-runtime/lib/use/use').default({ runtime: r });
+        });
+
+    runtimeCmd
+        .command('list')
+        .alias('ls')
+        .description('list all runtimes')
+        .action(() => {
+            require('@celljs/cli-runtime/lib/list/list').default({});
+        });
+
+    runtimeCmd
+        .command('uninstall [runtime]')
+        .alias('u')
+        .description('uninstall a runtime')
+        .action(r => {
+            require('@celljs/cli-runtime/lib/uninstall/uninstall').default({ runtime: r });
+        });
+
+    await new HookExecutor().executeHooks(context, 'cliHooks');
+    spinner.stop();
+
+    program
+        .arguments('[command]')
+        .action(cmd => {
+            program.outputHelp();
+            if (cmd) {
+                console.log();
+                console.log(chalk.red(`Unknown command ${chalk.yellow(cmd)}.`));
+                console.log();
+                suggestCommands(cmd, program);
+            }
+
+        });
+
+    runtimeCmd
+        .arguments('[command]')
+        .action(cmd => {
+            runtimeCmd.outputHelp();
+            if (cmd) {
+                console.log();
+                console.log(chalk.red(`Unknown command ${chalk.yellow(cmd)}.`));
+                console.log();
+                suggestCommands(cmd, runtimeCmd);
+            }
+
+        });
+    program.addHelpText('after', '\nUse "cell [command] --help" for more information about a command.');
+    program.parse(process.argv);
+
+})().catch(error => {
+    spinner.stop();
+    console.error(error);
+    process.exit(-1);
+});
+
+function suggestCommands(unknownCommand: string, main: Command) {
+    const availableCommands = main.commands.map((cmd: Command) => cmd.name());
+
+    let suggestion: string = '';
+
+    availableCommands.forEach((cmd: string) => {
+        const isBestMatch = leven(cmd, unknownCommand) < leven(suggestion, unknownCommand);
+        if (leven(cmd, unknownCommand) <= 3 && isBestMatch) {
+            suggestion = cmd;
+        }
+    });
+
+    if (suggestion) {
+        console.log(`  ${chalk.yellow(`Did you mean ${chalk.green(suggestion)}?`)}`);
+    }
+}
+

package/src/config/config.ts

@@ -0,0 +1,56 @@
+
+import { CliContext } from '@celljs/cli-common/lib/context/context-protocol';
+import { HookExecutor, HookStage } from '@celljs/cli-common/lib/hook/hook-executor';
+import { SettingsUtil } from '@celljs/cli-common/lib/settings/settings-util';
+
+import { dump } from 'js-yaml';
+
+export interface ConfigOptions {
+    frameworksUrl?: string;
+    frameworksUpstreamUrl?: boolean;
+    configFileAlias?: string;
+    defaultMode?: string[];
+    defaultRuntime?: string[];
+    show?: boolean;
+}
+
+export default async (ctx: CliContext, options: ConfigOptions) => {
+    try {
+        ctx.options = options;
+        const hookExecutor = new HookExecutor();
+        await hookExecutor.executeConfigHooks(ctx, HookStage.before);
+        if (options.defaultMode?.length) {
+            SettingsUtil.updateSettings({
+                defaultMode: options.defaultMode
+            });
+        }
+        if (options.defaultRuntime) {
+            SettingsUtil.updateSettings({
+                defaultRuntime: options.defaultRuntime
+            });
+        }
+        if (options.frameworksUpstreamUrl || options.frameworksUrl) {
+            SettingsUtil.updateSettings({
+                frameworks: {
+                    url: options.frameworksUrl,
+                    upstreamUrl: options.frameworksUpstreamUrl
+                }
+            });
+        }
+        if (options.configFileAlias) {
+            SettingsUtil.updateSettings({
+                configFileAlias: options.configFileAlias
+            });
+        }
+        if (options.show) {
+            ctx.output.settings = SettingsUtil.getSettings();
+        }
+        await hookExecutor.executeConfigHooks(ctx);
+        if (options.show) {
+            console.log(dump(ctx.output));
+        }
+    } catch (error) {
+        console.error(error);
+        process.exit(-1);
+    }
+};

package/src/deploy/deploy.ts

@@ -0,0 +1,31 @@
+
+import build from '../build/build';
+import { HookExecutor, HookStage } from '@celljs/cli-common/lib/hook/hook-executor';
+import { CliContext, ContextUtils } from '@celljs/cli-common/lib/context/context-protocol';
+import { CommandUtil, CommandType, CommandStage } from '@celljs/cli-common/lib/utils/command-util';
+
+export interface DeplyOptions {
+    skipBuild?: boolean;
+}
+
+export default async (ctx: CliContext, options: DeplyOptions) => {
+    try {
+        ctx.options = options;
+        ctx = ContextUtils.mergeContext(ctx, options);
+        const hookExecutor = new HookExecutor();
+        await CommandUtil.executeCommand(ctx, CommandType.DeployCommand, CommandStage.before);
+        await hookExecutor.executeDeployHooks(ctx, HookStage.before);
+        if (!options.skipBuild) {
+            await build(ctx, options);
+        }
+
+        await CommandUtil.executeCommand(ctx, CommandType.DeployCommand);
+
+        await hookExecutor.executeDeployHooks(ctx);
+        await hookExecutor.executeDeployHooks(ctx, HookStage.after);
+        await CommandUtil.executeCommand(ctx, CommandType.DeployCommand, CommandStage.after);
+    } catch (error) {
+        console.error(error);
+        process.exit(-1);
+    }
+};

package/src/info/info.ts

@@ -0,0 +1,23 @@
+import { CliContext } from '@celljs/cli-common/lib/context/context-protocol';
+import { HookExecutor, HookStage } from '@celljs/cli-common/lib/hook/hook-executor';
+import { LoggerUtil } from '@celljs/cli-common/lib/utils/logger-util';
+
+export interface InfoOptions {}
+
+export default async (ctx: CliContext, options: InfoOptions) => {
+    try {
+        ctx.options = options;
+        const hookExecutor = new HookExecutor();
+        await hookExecutor.executeInfoHooks(ctx, HookStage.before);
+
+        LoggerUtil.printStage(ctx);
+        LoggerUtil.printMode(ctx);
+        LoggerUtil.printTargets(ctx);
+        LoggerUtil.printComponents(ctx);
+
+        await hookExecutor.executeInfoHooks(ctx);
+    } catch (error) {
+        console.error(error);
+        process.exit(-1);
+    }
+};

package/src/init/init-manager.ts

@@ -0,0 +1,163 @@
+import { resolve, basename, relative, join } from 'path';
+import { existsSync, copy, readFile, writeJSON } from 'fs-extra';
+import { templates } from './templates';
+import { CliContext } from '@celljs/cli-common/lib/context/context-protocol';
+import { getPackager, spawnProcess } from '@celljs/cli-common/lib/packager/utils';
+import { HookExecutor } from '@celljs/cli-common/lib/hook/hook-executor';
+import { CommandUtil } from '@celljs/cli-common/lib/utils/command-util';
+import { prompts } from 'prompts';
+import * as ora from 'ora';
+const rimraf = require('rimraf');
+const chalk = require('chalk');
+import { ok } from 'assert';
+import { RuntimeUtil } from '@celljs/cli-runtime';
+const version = require('../../package.json').version;
+
+const PLACEHOLD = '{{ templatePath }}';
+
+const remoteTemplateRegex = /^(https?:|git@)/i;
+
+export interface Template {
+    name: string;
+    location: string;
+}
+
+export interface InitOptions {
+    template?: string;
+    packager?: 'pnpm' | 'yarn' | 'npm';
+    outputDir: string;
+}
+
+export class InitManager {
+
+    protected source: any[];
+    protected templateName: string;
+    protected location: string;
+    protected cliContext: CliContext;
+    constructor(protected readonly opts: InitOptions) {
+
+    }
+
+    async output(): Promise<void> {
+        await this.selectTemplate();
+        await this.checkOutputDir();
+        await this.doOutput();
+    }
+
+    async render(): Promise<void> {
+        const packageJsonPath = resolve(this.outputDir, 'package.json');
+        if (existsSync(packageJsonPath)) {
+            let packageJsonStr = await readFile(packageJsonPath, { encoding: 'utf8' });
+            packageJsonStr = packageJsonStr.replace(/{{\s*version\s*}}/g, version);
+            const packageJson = JSON.parse(packageJsonStr);
+            packageJson.name = basename(this.outputDir);
+            await writeJSON(packageJsonPath, packageJson, { encoding: 'utf8', spaces: 2 });
+        }
+    }
+
+    async install(): Promise<void> {
+        const pkg = CommandUtil.getPkg(undefined, this.outputDir);
+        const packager = this.opts.packager || pkg.rootComponentPackage.cellComponent?.packager;
+
+        await getPackager(packager, this.outputDir).install({}, this.outputDir);
+    }
+
+    async executeHooks(): Promise<void> {
+        const outputDir = this.outputDir;
+        const initContext = await this.getCliContext();
+        await new HookExecutor().executeHooks(initContext, 'initHooks');
+        console.log(chalk`{bold.green Success!} Initialized "${ this.templateName }" example in {bold.blue ${outputDir}}.`);
+        process.exit(0);
+    }
+
+    protected async getCliContext(): Promise<CliContext> {
+        if (!this.cliContext) {
+            this.cliContext = await RuntimeUtil.initRuntimeAndLoadContext(this.outputDir);
+            this.cliContext.location = this.realLocation;
+            this.cliContext.outputDir = this.outputDir;
+        }
+        return this.cliContext;
+    }
+
+    protected get outputDir(): string {
+        return resolve(process.cwd(),  this.opts.outputDir ? this.opts.outputDir : this.location.split('/').pop()!.replace('.git', ''));
+    }
+
+    protected async checkOutputDir(): Promise<void> {
+        if (existsSync(this.outputDir)) {
+            // eslint-disable-next-line @typescript-eslint/await-thenable
+            await prompts.confirm({
+                name: 'remove',
+                type: 'confirm',
+                message: `App already exists, remove the app (dir: ${join(relative(process.cwd(), this.outputDir))})`,
+                onState: ({ value }) => {
+                    if (value === true) {
+                        rimraf.sync(this.outputDir);
+                    } else {
+                        process.exit(0);
+                    }
+                }
+            });
+        }
+    }
+
+    protected toOfficialTemplate(name: string, location: string): any {
+        return { title: `${name} ${chalk.italic.gray('Official')}`, value: { location, name} };
+    }
+
+    protected toThirdPartyTemplate(item: any): any {
+        return { title: `${item.name} ${chalk.italic.gray(item.stargazers_count + '⭑')}`, value: { location: item.clone_url, name: item.name }};
+    }
+
+    protected async selectTemplate(): Promise<void> {
+        const { template } = this.opts;
+        if (template) {
+            this.templateName = template;
+            if (remoteTemplateRegex.test(template)) {
+                this.location = template;
+            } else {
+                Object.keys(templates).forEach(key => {
+                    if (key === template) {
+                        this.location = templates[key];
+                    }
+                });
+                ok(this.location, `"${template}" template not found`);
+            }
+            return;
+        }
+        const spinner = ora({ text: 'loading...', discardStdin: false }).start();
+        const officialTemplates = Object.keys(templates).map(key => this.toOfficialTemplate(key, templates[key]));
+        const choices = officialTemplates;
+        spinner.stop();
+        const answer = await prompts.autocomplete({
+            type: 'autocomplete',
+            name: 'template',
+            limit: 12,
+            message: 'Select a template to init',
+            choices,
+            suggest: async input => choices.filter(item => !input || item.title.toLowerCase().includes(input.toLowerCase()))
+        });
+        this.templateName = answer.name;
+        this.location = answer.location;
+    }
+
+    protected get realLocation() {
+        return this.location.replace(PLACEHOLD, resolve(__dirname, '..', '..', 'templates'));
+    }
+
+    protected async doOutput(): Promise<void> {
+        if (remoteTemplateRegex.test(this.location)) {
+            await this.outputRemoteTempate();
+        } else {
+            await this.outputLocalTemplate();
+        }
+    }
+    protected async outputLocalTemplate(): Promise<void> {
+        await copy(this.realLocation, this.outputDir);
+    }
+
+    protected outputRemoteTempate(): Promise<any> {
+        const dir = this.opts.outputDir ? [ this.opts.outputDir ] : [];
+        return spawnProcess('git', [ 'clone', '--depth=1', this.location, ...dir ], { stdio: 'inherit' });
+    }
+}

package/src/init/init.ts

@@ -0,0 +1,15 @@
+import { InitManager, InitOptions } from './init-manager';
+
+export default async (options: InitOptions) => {
+    try {
+        const initManager = new InitManager(options);
+        await initManager.output();
+        await initManager.render();
+        await initManager.install();
+        await initManager.executeHooks();
+    } catch (error) {
+        console.error(error);
+        process.exit(-1);
+    }
+
+};

package/src/init/templates.ts

@@ -0,0 +1,21 @@
+export const templates: any = {
+    'backend-app': '{{ templatePath }}/backend-app',
+    'sample-app': '{{ templatePath }}/sample-app',
+    'cell-component': '{{ templatePath }}/cell-component',
+    'docker-app': '{{ templatePath }}/docker-app',
+    'monorepo': '{{ templatePath }}/monorepo',
+    'nest-app': '{{ templatePath }}/nest-app',
+    'nextjs-app': '{{ templatePath }}/nextjs-app',
+    'koa-app': '{{ templatePath }}/koa-app',
+    'vue-app': '{{ templatePath }}/vue-app',
+    'database-app': '{{ templatePath }}/database-app',
+    'jwt-app': '{{ templatePath }}/jwt-app',
+    'accounts': '{{ templatePath }}/accounts',
+    'schedule': '{{ templatePath }}/schedule',
+    'admin-app': '{{ templatePath }}/admin-app',
+    'microservice': '{{ templatePath }}/microservice',
+    'standalone-app': '{{ templatePath }}/standalone-app',
+    'file-service': '{{ templatePath }}/file-service',
+    'puppeteer': '{{ templatePath }}/puppeteer',
+    'mycli': '{{ templatePath }}/mycli'
+};

package/src/package.spec.ts

@@ -0,0 +1,4 @@
+describe('cli package', () => {
+
+    it('support code coverage statistics', () => {});
+});

package/src/props/props.ts

@@ -0,0 +1,48 @@
+import { CliContext } from '@celljs/cli-common/lib/context/context-protocol';
+import { ConfigUtil } from '@celljs/cli-common/lib/utils/config-util';
+import { dump } from 'js-yaml';
+import * as traverse from 'traverse';
+const chalk = require('chalk');
+
+export interface PropsOptions {
+    backend?: boolean;
+    frontend?: boolean;
+    name?: string;
+}
+
+export default async (ctx: CliContext, options: PropsOptions) => {
+    try {
+        ctx.options = options;
+        let backendProps: any;
+        let frontendProps: any;
+
+        if (options.frontend) {
+            frontendProps = ConfigUtil.getFrontendConfig(ctx.cfg);
+        } else if (options.backend) {
+            backendProps = ConfigUtil.getBackendConfig(ctx.cfg);
+        } else {
+            frontendProps = ConfigUtil.getFrontendConfig(ctx.cfg);
+            backendProps = ConfigUtil.getBackendConfig(ctx.cfg);
+        }
+
+        if (frontendProps) {
+            console.log(chalk`{bold.magenta - Frontend: }`);
+            if (options.name) {
+                console.log(`${options.name}: ${traverse(frontendProps).get(options.name.split('.'))}`);
+            } else {
+                console.log(dump(ConfigUtil.getFrontendConfig(ctx.cfg), { skipInvalid: true }));
+            }
+        }
+        if (backendProps) {
+            console.log(chalk`{bold.magenta - Backend: }`);
+            if (options.name) {
+                console.log(`${options.name}: ${traverse(backendProps).get(options.name.split('.'))}`);
+            } else {
+                console.log(dump(ConfigUtil.getBackendConfig(ctx.cfg), { skipInvalid: true }));
+            }
+        }
+    } catch (error) {
+        console.error(error);
+        process.exit(-1);
+    }
+};

package/src/serve/serve-manager.ts

@@ -0,0 +1,51 @@
+import { LoggerUtil } from '@celljs/cli-common/lib/utils/logger-util';
+import { CommandUtil, CommandType, CommandStage } from '@celljs/cli-common/lib/utils/command-util';
+import { CliContext } from '@celljs/cli-common/lib/context/context-protocol';
+import { HookExecutor, HookStage } from '@celljs/cli-common/lib/hook/hook-executor';
+import { ConfigUtil } from '@celljs/cli-common/lib/utils';
+
+export class ServeManager {
+
+    constructor(
+        protected readonly context: CliContext) {
+    }
+
+    protected log() {
+        LoggerUtil.printStage(this.context);
+        LoggerUtil.printMode(this.context);
+        LoggerUtil.printTargets(this.context);
+        LoggerUtil.printComponents(this.context);
+    }
+
+    async start() {
+
+        this.log();
+
+        const commandRender = async (command: string, target: string) => {
+            const { cfg, port } = this.context;
+            const realPort = ConfigUtil.getPort(cfg, target, port);
+            return command
+                .replace(/\$PATH/g, ConfigUtil.getCellConfig(cfg, target).server?.path)
+                .replace(/\$PORT/g, realPort);
+        };
+
+        const hookExecutor = new HookExecutor();
+        await CommandUtil.executeCommand(this.context, CommandType.CompileCommand, CommandStage.before);
+        await hookExecutor.executeCompileHooks(this.context, HookStage.before);
+
+        await CommandUtil.executeCommand(this.context, CommandType.CompileCommand);
+        await hookExecutor.executeCompileHooks(this.context);
+
+        await hookExecutor.executeCompileHooks(this.context, HookStage.after);
+        await CommandUtil.executeCommand(this.context, CommandType.CompileCommand, CommandStage.after);
+
+        await CommandUtil.executeCommand(this.context, CommandType.ServeCommand, CommandStage.before, commandRender);
+        await hookExecutor.executeServeHooks(this.context, HookStage.before);
+
+        await CommandUtil.executeCommand(this.context, CommandType.ServeCommand, CommandStage.on, commandRender);
+        await hookExecutor.executeServeHooks(this.context);
+
+        await hookExecutor.executeServeHooks(this.context, HookStage.after);
+        await CommandUtil.executeCommand(this.context, CommandType.ServeCommand, CommandStage.after, commandRender);
+    }
+}

package/src/serve/serve.ts

@@ -0,0 +1,19 @@
+
+import { ServeManager } from './serve-manager';
+import { CliContext, ContextUtils } from '@celljs/cli-common/lib/context/context-protocol';
+
+export interface ServeOptions {
+    port?: string;
+}
+
+export default async (ctx: CliContext, options: ServeOptions) => {
+    try {
+        ctx.options = options;
+        ctx =  ContextUtils.mergeContext(ctx, { dev: true, ...options });
+        await new ServeManager(ctx).start();
+    } catch (error) {
+        console.error(error);
+        process.exit(-1);
+    }
+
+};