@celljs/cli 3.0.0

package/templates/monorepo/scripts/check-publish.js

@@ -0,0 +1,40 @@
+// @ts-check
+
+const path = require('path');
+const chalk = require('chalk');
+const cp = require('child_process');
+const fs = require('fs');
+
+checkPublish().catch(error => {
+    console.error(error);
+    process.exitCode = 1;
+});
+
+async function checkPublish() {
+    const workspaces = JSON.parse(cp.execSync('yarn --silent workspaces info').toString());
+    await Promise.all(Object.values(workspaces).map(async workspace => {
+        const packagePath = path.resolve(workspace.location, 'package.json');
+        const pck = JSON.parse(await fs.promises.readFile(packagePath, 'utf8'));
+        if (!pck.private) {
+            const pckName = `${pck.name}@${pck.version}`;
+            const npmViewOutput = await new Promise(
+                resolve => cp.exec(`npm view ${pckName} version --json`,
+                    (error, stdout, stderr) => {
+                        if (error) {
+                            console.error(error);
+                            resolve('');
+                        } else {
+                            resolve(stdout.trim());
+                        }
+                    }
+                )
+            );
+            if (npmViewOutput) {
+                console.info(`${pckName}: published`);
+            } else {
+                console.error(`(${chalk.red('ERR')}) ${pckName}: ${chalk.red('NOT')} published`);
+                process.exitCode = 1;
+            }
+        }
+    }));
+}

package/templates/monorepo/scripts/compile-references.js

@@ -0,0 +1,286 @@
+// @ts-check
+'use-strict';
+
+const cp = require('child_process');
+const path = require('path').posix;
+const fs = require('fs');
+
+const ROOT = path.join(__dirname, '..');
+
+const DRY_RUN = popFlag(process.argv, '--dry-run');
+
+const FORCE_REWRITE = popFlag(process.argv, '--force-rewrite') && !DRY_RUN;
+
+/** @type {{ [packageName: string]: YarnWorkspace }} */
+const YARN_WORKSPACES = JSON.parse(cp.execSync('yarn --silent workspaces info').toString());
+
+// Add the package name inside each package object.
+for (const [packageName, yarnWorkspace] of Object.entries(YARN_WORKSPACES)) {
+    yarnWorkspace.name = packageName;
+}
+
+/** @type {YarnWorkspace} */
+const MONOREPO = {
+    name: 'monorepo',
+    workspaceDependencies: Object.keys(YARN_WORKSPACES),
+    location: ROOT,
+};
+
+try {
+    let rewriteRequired = false;
+    let result = false;
+
+    // Configure all `compile.tsconfig.json` files of this monorepo
+    for (const packageName of Object.keys(YARN_WORKSPACES)) {
+        const workspacePackage = YARN_WORKSPACES[packageName];
+        const tsconfigCompilePath = path.join(ROOT, workspacePackage.location, 'compile.tsconfig.json');
+        const references = getTypescriptReferences(workspacePackage);
+        result = configureTypeScriptCompilation(workspacePackage, tsconfigCompilePath, references);
+        rewriteRequired = rewriteRequired || result;
+    }
+
+    // Configure our root compilation configuration, living inside `configs/root-compilation.tsconfig.json`.
+    const configsFolder = path.join(ROOT, 'configs');
+    const tsconfigCompilePath = path.join(configsFolder, 'root-compilation.tsconfig.json');
+    const references = getTypescriptReferences(MONOREPO, configsFolder);
+    result = configureTypeScriptCompilation(MONOREPO, tsconfigCompilePath, references);
+    rewriteRequired = rewriteRequired || result;
+
+    // Configure the root `tsconfig.json` for code navigation using `tsserver`.
+    const tsconfigNavPath = path.join(ROOT, 'tsconfig.json');
+    result = configureTypeScriptNavigation(MONOREPO, tsconfigNavPath);
+    rewriteRequired = rewriteRequired || result;
+
+    // CI will be able to tell if references got changed by looking at the exit code.
+    if (rewriteRequired) {
+        if (DRY_RUN) {
+            // Running a dry run usually only happens when a developer or CI runs the tests, so we only print the help then.
+            console.error('TypeScript references seem to be out of sync, run "yarn prepare:references" to fix.');
+            process.exitCode = 1;
+        } else {
+            console.warn('TypeScript references were out of sync and got updated.');
+        }
+    }
+
+} catch (error) {
+    console.error(error);
+    process.exitCode = 1;
+}
+
+/**
+ * @param {YarnWorkspace} requestedPackage
+ * @param {string} [overrideLocation] affects how relative paths are computed.
+ * @returns {string[]} project references for `requestedPackage`.
+ */
+function getTypescriptReferences(requestedPackage, overrideLocation) {
+    const references = [];
+    for (const dependency of requestedPackage.workspaceDependencies || []) {
+        const depWorkspace = YARN_WORKSPACES[dependency];
+        const depConfig = path.join(depWorkspace.location, 'compile.tsconfig.json');
+        if (!fs.existsSync(depConfig)) {
+            continue;
+        }
+        const relativePath = path.relative(overrideLocation || requestedPackage.location, depWorkspace.location);
+        references.push(relativePath);
+    }
+    return references;
+}
+
+/**
+ * Wires a given compilation tsconfig file according to the provided references.
+ * This allows TypeScript to operate in build mode.
+ *
+ * @param {YarnWorkspace} targetPackage for debug purpose.
+ * @param {string} tsconfigPath path to the tsconfig file to edit.
+ * @param {string[]} references list of paths to the related project roots.
+ * @returns {boolean} rewrite was needed.
+ */
+function configureTypeScriptCompilation(targetPackage, tsconfigPath, references) {
+    if (!fs.existsSync(tsconfigPath)) {
+        return false;
+    }
+    const tsconfigJson = readJsonFile(tsconfigPath);
+
+    let needRewrite = FORCE_REWRITE;
+
+    if (!tsconfigJson.compilerOptions) {
+        // Somehow no `compilerOptions` literal is defined.
+        tsconfigJson.compilerOptions = {
+            composite: true,
+            rootDir: 'src',
+            outDir: 'lib',
+        };
+        needRewrite = true;
+
+    } else if (!tsconfigJson.compilerOptions.composite) {
+        // `compilerOptions` is missing the `composite` literal.
+        tsconfigJson.compilerOptions = {
+            composite: true,
+            ...tsconfigJson.compilerOptions,
+        };
+        needRewrite = true;
+    }
+
+    /** @type {string[]} */
+    const tsconfigReferences = references
+        .map(reference => path.join(reference, 'compile.tsconfig.json'));
+
+    /** @type {string[]} */
+    const currentReferences = (tsconfigJson['references'] || [])
+        // We will work on a set of paths, easier to handle than objects.
+        .map(reference => reference.path)
+        // Remove any invalid reference (maybe outdated).
+        .filter((referenceRelativePath, index, self) => {
+            if (!tsconfigReferences.includes(referenceRelativePath)) {
+                // Found a reference that wasn't automatically computed, will remove.
+                console.warn(`error: ${targetPackage.name} untracked reference: ${referenceRelativePath}`);
+                needRewrite = true;
+                return false; // remove
+            }
+            if (self.indexOf(referenceRelativePath) !== index) {
+                // Remove duplicates.
+                console.error(`error: ${targetPackage.name} duplicate reference: ${referenceRelativePath}`);
+                needRewrite = true;
+                return false; // remove
+            }
+            const referencePath = path.join(path.dirname(tsconfigPath), referenceRelativePath);
+            try {
+                const referenceStat = fs.statSync(referencePath);
+                if (referenceStat.isDirectory() && fs.statSync(path.join(referencePath, 'tsconfig.json')).isFile()) {
+                    return true; // keep
+                } else if (referenceStat.isFile()) { // still could be something else than a tsconfig, but good enough.
+                    return true; // keep
+                }
+            } catch {
+                // passthrough
+            }
+            console.error(`error: ${targetPackage.name} invalid reference: ${referenceRelativePath}`);
+            needRewrite = true;
+            return false; // remove
+        });
+
+    for (const tsconfigReference of tsconfigReferences) {
+        if (!currentReferences.includes(tsconfigReference)) {
+            console.error(`error: ${targetPackage.name} missing reference: ${tsconfigReference}`);
+            currentReferences.push(tsconfigReference);
+            needRewrite = true;
+        }
+    }
+    if (!DRY_RUN && needRewrite) {
+        tsconfigJson.references = currentReferences.map(path => ({ path }));
+        const content = JSON.stringify(tsconfigJson, undefined, 2);
+        fs.writeFileSync(tsconfigPath, content + '\n');
+        console.warn(`info: ${tsconfigPath} updated.`);
+    }
+    return needRewrite;
+}
+
+/**
+ * Wire the root `tsconfig.json` to map scoped import to real location in the monorepo.
+ * This setup is a shim for the TypeScript language server to provide cross-package navigation.
+ * Compilation is done via `compile.tsconfig.json` files.
+ *
+ * @param {YarnWorkspace} targetPackage for debug purpose.
+ * @param {string} tsconfigPath
+ * @returns {boolean} rewrite was needed.
+ */
+function configureTypeScriptNavigation(targetPackage, tsconfigPath) {
+    const tsconfigJson = readJsonFile(tsconfigPath);
+
+    let needRewrite = FORCE_REWRITE;
+
+    if (typeof tsconfigJson.compilerOptions === 'undefined') {
+        // Somehow no `compilerOptions` literal is defined.
+        tsconfigJson.compilerOptions = {
+            baseUrl: '.',
+            paths: {},
+        };
+        needRewrite = true;
+
+    } else if (typeof tsconfigJson.compilerOptions.paths === 'undefined') {
+        // `compilerOptions` is missing the `paths` literal.
+        tsconfigJson.compilerOptions = {
+            ...tsconfigJson.compilerOptions,
+            paths: {},
+        };
+        needRewrite = true;
+    }
+
+    /** @type {{ [prefix: string]: string[] }} */
+    const currentPaths = tsconfigJson.compilerOptions.paths;
+
+    for (const packageName of MONOREPO.workspaceDependencies) {
+        const depWorkspace = YARN_WORKSPACES[packageName];
+
+        /** @type {string} */
+        let originalImportPath;
+        /** @type {string} */
+        let mappedFsPath;
+
+        const depSrcPath = path.join(depWorkspace.location, 'src');
+        const depConfigPath = path.join(depWorkspace.location, 'compile.tsconfig.json');
+
+        if (fs.existsSync(depConfigPath) && fs.existsSync(depSrcPath)) {
+            // If it is a TypeScript dependency, map `lib` imports to our local sources in `src`.
+            const depConfigJson = readJsonFile(depConfigPath);
+            originalImportPath = `${packageName}/${depConfigJson.compilerOptions.outDir}/*`;
+            mappedFsPath = path.relative(MONOREPO.location, path.join(depSrcPath, '*'));
+
+        } else {
+            // I don't really know what to do here, simply point to our local package root.
+            originalImportPath = `${packageName}/*`;
+            mappedFsPath = path.relative(MONOREPO.location, path.join(depWorkspace.location, '*'));
+        }
+
+        /** @type {string[] | undefined} */
+        const currentFsPaths = currentPaths[originalImportPath];
+
+        if (typeof currentFsPaths === 'undefined' || currentFsPaths.length !== 1 || currentFsPaths[0] !== mappedFsPath) {
+            console.error(`error: ${targetPackage.name} invalid mapped path: {"${originalImportPath}": "${currentFsPaths}"}`);
+            currentPaths[originalImportPath] = [mappedFsPath];
+            needRewrite = true;
+        }
+    }
+    if (!DRY_RUN && needRewrite) {
+        const content = JSON.stringify(tsconfigJson, undefined, 2);
+        fs.writeFileSync(tsconfigPath, content + '\n');
+        console.warn(`info: ${tsconfigPath} updated.`);
+    }
+    return needRewrite;
+}
+
+/**
+ *
+ * @param {string[]} argv
+ * @param {string} flag
+ * @returns {boolean}
+ */
+function popFlag(argv, flag) {
+    const flagIndex = argv.indexOf(flag)
+    if (flagIndex !== -1) {
+        argv.splice(flagIndex, 1);
+        return true;
+    } else {
+        return false;
+    }
+}
+
+/**
+ * @param {string} filePath
+ * @returns {any}
+ */
+function readJsonFile(filePath) {
+    try {
+        return JSON.parse(fs.readFileSync(filePath).toString());
+    } catch (error) {
+        console.error('ParseError in file:', filePath);
+        throw error;
+    }
+}
+
+/**
+ * @typedef YarnWorkspace
+ * @property {string} name
+ * @property {string} location
+ * @property {string[]} workspaceDependencies
+ */

package/templates/monorepo/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "extends": "@celljs/component/configs/base.tsconfig.json",
+  "compilerOptions": {
+    "allowJs": true,
+    "noEmit": true,
+    "baseUrl": ".",
+    "paths": {
+      "@app/core/lib/*": [
+        "packages/core/src/*"
+      ],
+      "@app/app-sample-app/*": [
+        "apps/sample-app/*"
+      ]
+    }
+  },
+  "include": [
+    "packages/*/src",
+    "apps/*/test"
+  ]
+}

package/templates/monorepo/tsfmt.json

@@ -0,0 +1,3 @@
+{
+  "insertSpaceAfterFunctionKeywordForAnonymousFunctions": true
+}

package/templates/mycli/.vscode/launch.json

@@ -0,0 +1,33 @@
+{
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "type": "pwa-node",
+            "request": "launch",
+            "name": "mycli init",
+            "program": "${workspaceRoot}/bin/mycli-init",
+            "cwd": "${workspaceFolder}",
+            "sourceMaps": true,
+            "env": {
+                "NODE_ENV": "development"
+            },
+            "smartStep": true,
+            "internalConsoleOptions": "openOnSessionStart",
+            "outputCapture": "std"
+        },
+        {
+            "type": "pwa-node",
+            "request": "launch",
+            "name": "mycli deploy",
+            "program": "${workspaceRoot}/bin/mycli-deploy",
+            "cwd": "${workspaceFolder}",
+            "sourceMaps": true,
+            "env": {
+                "NODE_ENV": "development"
+            },
+            "smartStep": true,
+            "internalConsoleOptions": "openOnSessionStart",
+            "outputCapture": "std"
+        }
+    ]
+}

package/templates/mycli/bin/mycli

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+require('../lib/mycli')

package/templates/mycli/bin/mycli-deploy

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+require('../lib/deploy/deploy')

package/templates/mycli/bin/mycli-init

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+require('../lib/init/init')

package/templates/mycli/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "mycli",
+  "version": "0.0.0",
+  "license": "MIT",
+  "files": [
+    "lib",
+    "bin",
+    "src",
+    "templates"
+  ],
+  "bin": {
+    "mycli": "./bin/mycli"
+  },
+  "dependencies": {
+    "@celljs/core": "{{ version }}",
+    "chalk": "^4.1.0",
+    "commander": "^4.0.1",
+    "fs-extra": "^11.1.1",
+    "prompts": "^2.4.2"
+  },
+  "devDependencies": {
+    "@celljs/cli": "{{ version }}",
+    "@types/fs-extra": "^11.0.1",
+    "rimraf": "^5.0.2",
+    "typescript": "~4.5.5"
+  },
+  "scripts": {
+    "prepare": "yarn run clean & yarn run build",
+    "clean": "rimraf lib",
+    "build": "tsc",
+    "watch": "tsc -w"
+  }
+}

package/templates/mycli/src/bootstrap.ts

@@ -0,0 +1,7 @@
+import { ApplicationFactory } from '@celljs/core/lib/common/application/application-factory';
+import { MycliModule } from './module';
+
+export async function bootstrap() {
+    const app = await ApplicationFactory.create({}, MycliModule);       // 根据应用属性配置和相关的应用模块创建应用
+    await app.start();                                                  // 启动应用
+}

package/templates/mycli/src/constants.ts

@@ -0,0 +1 @@
+export const CONTEXT = 'CONTEXT';

package/templates/mycli/src/deploy/deploy-manager.ts

@@ -0,0 +1,12 @@
+import { Component } from '@celljs/core';
+import * as chalk from 'chalk';
+
+
+@Component()
+export class DeployManager {
+
+    async deploy(): Promise<void> {
+        console.log(chalk`{bold.green Success!}`);
+    }
+
+}

package/templates/mycli/src/deploy/deploy.ts

@@ -0,0 +1,16 @@
+
+import { bootstrap } from '../bootstrap';
+import { ContainerUtil } from '@celljs/core';
+import * as program from 'commander';
+import { DeployManager } from './deploy-manager';
+
+program
+    .name('cell deploy')
+    .description('init a application')
+    .parse(process.argv);
+
+(async () => {
+    await bootstrap();
+    const deployManager = ContainerUtil.get<DeployManager>(DeployManager);
+    await deployManager.deploy();
+})();

package/templates/mycli/src/deploy/index.ts

@@ -0,0 +1 @@
+export * from './deploy-manager';

package/templates/mycli/src/index.ts

@@ -0,0 +1,2 @@
+export * from './init';
+export * from './deploy';

package/templates/mycli/src/init/index.ts

@@ -0,0 +1 @@
+export * from './init-manager';

package/templates/mycli/src/init/init-manager.ts

@@ -0,0 +1,85 @@
+import { resolve } from 'path';
+import { existsSync, copy } from 'fs-extra';
+import { prompts } from 'prompts';
+import { templates } from './templates';
+import { Component, Autowired } from '@celljs/core';
+import { CONTEXT } from '../constants';
+import * as chalk from 'chalk';
+
+const PLACEHOLD = '{{ templatePath }}';
+
+export interface Template {
+    name: string;
+    location: string;
+}
+
+@Component()
+export class InitManager {
+
+    protected name: string;
+    protected location: string;
+
+    @Autowired(CONTEXT)
+    protected context: any;
+
+    async output(): Promise<void> {
+        await this.selectTemplate();
+        await this.checkOutputDir();
+        await this.doOutput();
+    }
+
+    protected get outputDir(): string {
+        return resolve(process.cwd(), this.context.outputDir, this.context.name);
+    }
+
+    protected async checkOutputDir() {
+        if (existsSync(this.outputDir)) {
+            await prompts.confirm({
+                name: 'overwrite',
+                type: 'confirm',
+                message: 'Project already exists, overwrite the project',
+                onState: ({ value }) => {
+                    if (value !== true) {
+                        process.exit(-1);
+                    }
+                }
+            });
+            
+        }
+    }
+
+    protected toTemplateMap(name: string, location: string) {
+        return { title: name, value: { location, name} };
+    }
+
+    protected async selectTemplate(): Promise<void> {
+        const templateMap = Object.keys(templates).map(key => this.toTemplateMap(key, templates[key]));
+        let answers;
+        if (templateMap.length == 1) {
+            answers = { item: templateMap[0].value };
+        } else {
+            answers = await prompts.autocomplete({
+                name: 'item',
+                type: 'autocomplete',
+                message: 'Select a template to init',
+                choices: templateMap,
+                suggest: async input => {
+                    return templateMap.filter(item => !input || item.title.toLowerCase().includes(input.toLowerCase()));
+                }
+            });
+        }
+        
+        this.name = answers.name;
+        this.context.name = this.context.name || answers.name;
+        this.location = answers.location;
+    }
+
+    protected get realLocation() {
+        return this.location.replace(PLACEHOLD, resolve(__dirname, '..', '..', 'templates'));
+    }
+
+    protected async doOutput() {
+        await copy(this.realLocation, this.outputDir);
+        console.log(chalk`{bold.green Success!}`);
+    }
+}

package/templates/mycli/src/init/init.ts

@@ -0,0 +1,25 @@
+import { bootstrap } from '../bootstrap';
+import * as program from 'commander';
+import { InitManager } from './init-manager';
+import { CONTEXT } from '../constants';
+import { ContainerProvider } from '@celljs/core';
+
+program
+    .name('cell init')
+    .usage('[options] [name]')
+    .option('-o, --output-dir [path]', 'output directory', '.')
+    .description('init a application')
+    .parse(process.argv);
+
+(async () => {
+    await bootstrap();
+    let name = undefined;
+    if (program.args.length > 0) {
+        name = program.args[0];
+    }
+    const outputDir = program.outputDir;
+    const container = await ContainerProvider.asyncProvide();
+    container.bind(CONTEXT).toConstantValue({ name, outputDir, program })
+    const initManager = container.get(InitManager);
+    await initManager.output();
+})();

package/templates/mycli/src/init/templates.ts

@@ -0,0 +1,3 @@
+export const templates: any = {
+    'application-template': '{{ templatePath }}/application-template'
+};

package/templates/mycli/src/module.ts

@@ -0,0 +1,3 @@
+import './index';
+import { autoBind } from '@celljs/core';
+export const MycliModule = autoBind();

package/templates/mycli/src/mycli.ts

@@ -0,0 +1,13 @@
+import * as program from 'commander';
+import { bootstrap } from './bootstrap';
+const pkg = require('../package.json');
+
+(async () => {
+  await bootstrap();
+  program
+    .version(pkg.version)
+    .command('init [name]', 'init a fc application')
+    .command('deploy [options]', 'deply a fc application')
+    .parse(process.argv);
+
+})();

package/templates/mycli/tsconfig.json

@@ -0,0 +1,29 @@
+{
+  "compilerOptions": {
+    "skipLibCheck": true,
+    "declaration": true,
+    "declarationMap": true,
+    "noImplicitAny": true,
+    "noEmitOnError": false,
+    "noImplicitThis": true,
+    "noUnusedLocals": true,
+    "strictNullChecks": true,
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "downlevelIteration": true,
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "jsx": "react",
+    "target": "ES2017",
+    "lib": [
+      "ES2017",
+      "dom"
+    ],
+    "sourceMap": true,
+    "rootDir": "src",
+    "outDir": "lib"
+  },
+  "include": [
+    "src"
+  ]
+}