@ones-open/cli 2.1.0 → 2.1.1

package/bin/index.es.js

@@ -0,0 +1,261 @@
+#!/usr/bin/env node
+import { ONESProjectTemplate, getCliVersionByMetaPath, Version, tryGitInit, renameHiddenTemplateFiles, getNpm, getPackageInNodeModulesDir } from '@ones-open/cli-utils';
+import chalk from 'chalk';
+import { Command, Option } from 'commander';
+import _includesInstanceProperty from '@babel/runtime-corejs3/core-js-stable/instance/includes';
+import { checkIsLegalPluginType, getPluginProjectCreatingTasks } from '@ones-open/cli-plugin';
+import { execa } from 'execa';
+import { pathExists, copy } from 'fs-extra';
+import inquirer from 'inquirer';
+import Listr from 'listr';
+import { isAbsolute, join, basename, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import envinfo from 'envinfo';
+import { cwd } from 'process';
+
+/* eslint-disable no-console */
+const defaultConfig = {
+  System: ['OS', 'CPU', 'Memory', 'Shell'],
+  Binaries: ['Node', 'npm'],
+  npmPackages: ['@ones-open/cli-utils', '@ones-open/cli-plugin', '@ones-open/cli-monorepo'],
+  npmGlobalPackages: ['@ones-open/cli']
+};
+const defaultOptions = {
+  duplicates: true,
+  showNotFound: true
+};
+async function printEnvironmentInfo(config = defaultConfig, options = defaultOptions) {
+  const info = await envinfo.run(config, options);
+  console.log(chalk.bold('\nEnvironment Info:'), info);
+}
+
+const LEGAL_PROJECT_TYPE = Object.values(ONESProjectTemplate);
+const LEGAL_PROJECT_TYPE_SET = new Set(LEGAL_PROJECT_TYPE);
+const LEGAL_POLICY = ['simple', 'standard'];
+function isLegalProjectType(projectType) {
+  return LEGAL_PROJECT_TYPE_SET.has(projectType);
+}
+function isLegalPolicy(policy) {
+  return _includesInstanceProperty(LEGAL_POLICY).call(LEGAL_POLICY, policy);
+}
+async function getRootPath(currentWorkingDirectory, specificPath) {
+  const hasSpecificPath = specificPath && specificPath.length > 0;
+  if (hasSpecificPath) {
+    // we had to check if the path is absolute or not
+    const isAbsolutePath = isAbsolute(specificPath);
+    const root = isAbsolutePath ? specificPath : join(currentWorkingDirectory, specificPath);
+    const isPathExists = await pathExists(root);
+    if (!isPathExists) {
+      throw new Error('The specific path does not exist on the file system');
+    }
+    return {
+      hasSpecificPath,
+      root,
+      projectName: basename(root)
+    };
+  }
+  return {
+    hasSpecificPath,
+    root: currentWorkingDirectory,
+    projectName: basename(currentWorkingDirectory)
+  };
+}
+
+/**
+ * Copy the project basic template files
+ *
+ * We need to consider the path of current file path after complication.
+ * When we compute the path on the file system.
+ *
+ * e.g:
+ *
+ *   Current file in `/Users/user/ones/cli/src/bin/index.ts`
+ *   Then the location of current file after complication is `/Users/user/ones/cli/bin/index.js`
+ */
+async function copyBasicTemplateFiles(projectType, projectPath) {
+  const currentFilePath = fileURLToPath(import.meta.url);
+  const currentFileDir = dirname(currentFilePath);
+  const templatePath = join(currentFileDir, '../template');
+  if (projectType === ONESProjectTemplate.Monorepo) {
+    await copy(templatePath, projectPath);
+    await renameHiddenTemplateFiles(projectPath);
+  } else {
+    // Only copy the package.json for the plugin project creating
+    const basicTemplatePackageJsonPath = join(templatePath, 'package.json');
+    const packageJsonPath = join(projectPath, 'package.json');
+    await copy(basicTemplatePackageJsonPath, packageJsonPath);
+  }
+}
+async function installSubCli({
+  root,
+  subCliName,
+  installLocalDependencies,
+  distTag
+}) {
+  const cliNameWithVersionSuffix = `${subCliName}@${distTag}`;
+  const installCommand = getNpm();
+  const installArgs = installLocalDependencies ? ['link', subCliName, '--save-dev', '--no-optional'] : ['install', cliNameWithVersionSuffix, '--save-dev', '--no-optional'];
+  await execa(installCommand, installArgs, {
+    cwd: root,
+    stdio: 'ignore'
+  });
+  const subCliPath = getPackageInNodeModulesDir(root, subCliName);
+  const subCliPackageJsonPath = join(subCliPath, 'package.json');
+  const isSubCliInstalled = await pathExists(subCliPackageJsonPath);
+  if (!isSubCliInstalled) {
+    throw new Error(`${subCliName} does not exist in node_modules`);
+  }
+}
+
+/**
+ *  TODO: support different project types
+ */
+function getExternalTaskByTemplateType(currentWorkingDirectory, projectCreatingParams, options) {
+  const {
+    template
+  } = projectCreatingParams;
+  if (template === ONESProjectTemplate.Plugin) {
+    return getPluginProjectCreatingTasks({
+      currentWorkingDirectory,
+      projectCreatingParams,
+      options
+    });
+  }
+  return undefined;
+}
+async function createProject(rawProjectName, options) {
+  try {
+    const {
+      projectType,
+      specificPath,
+      useDefaultPreset,
+      installLocalDependencies,
+      distTag: rawDistTag,
+      pluginType,
+      policy
+    } = options;
+    const cliVersion = await getCliVersionByMetaPath(import.meta.url);
+    if (!cliVersion) throw new Error('Get sub cli version failed.');
+    const distTag = rawDistTag ? rawDistTag :
+    // Get ONES CLI major version to match correct dependencies version
+    new Version(cliVersion).major;
+    if (!projectType || !isLegalProjectType(projectType)) {
+      throw new Error(`Illegal project type: ${projectType}`);
+    }
+    if (!checkIsLegalPluginType(pluginType)) {
+      throw new Error(`Illegal plugin type: ${pluginType}`);
+    }
+    if (!isLegalPolicy(policy)) {
+      throw new Error(`Illegal policy: ${policy}`);
+    }
+    const {
+      root,
+      projectName
+    } = await getRootPath(cwd(), specificPath);
+    const defaultProjectName = rawProjectName || projectName;
+    let projectCreatingParams = {
+      template: ONESProjectTemplate.Plugin,
+      name: defaultProjectName,
+      description: '',
+      appID: ''
+    };
+    const prompts = [{
+      type: 'list',
+      name: 'template',
+      message: 'Choose a template:',
+      choices: LEGAL_PROJECT_TYPE,
+      default: projectCreatingParams.template,
+      // Temporary hide the monorepo template type until we support it
+      when: false
+      // when: !projectType || !templates.includes(projectType),
+    }, {
+      type: 'input',
+      name: 'appID',
+      message: 'Project app ID(Refer to https://developer.ones.com/docs/guide/developer-license to learn how to get the appID.):',
+      validate: rawInput => {
+        const input = rawInput.trim();
+        if (input.length === 0) return 'Project app ID is required and cannot be empty';
+        return true;
+      }
+    }, {
+      type: 'input',
+      name: 'name',
+      message: 'Project name:',
+      default: defaultProjectName,
+      validate: rawInput => {
+        const input = rawInput.trim();
+        if (input.length === 0) return 'Project name is required and cannot be empty';
+        return true;
+      },
+      when: !useDefaultPreset
+    }, {
+      type: 'input',
+      name: 'description',
+      message: 'Project description:',
+      when: !useDefaultPreset
+    }];
+
+    // display interactive prompts
+    const answers = await inquirer.prompt(prompts);
+    Object.entries(answers).forEach(([key, value]) => {
+      if (!value) return;
+      projectCreatingParams = {
+        ...projectCreatingParams,
+        [key]: value
+      };
+    });
+    const projectCreatingTasks = [{
+      title: 'Git init',
+      task: async (ctx, task) => {
+        try {
+          await tryGitInit(root);
+        } catch (error) {
+          if (error instanceof Error) {
+            const {
+              message
+            } = error;
+            task.skip(message);
+          }
+        }
+      }
+    }, {
+      title: 'Copy basic template files',
+      task: () => copyBasicTemplateFiles(projectCreatingParams.template, root)
+    }, {
+      title: 'Install sub CLI dependencies',
+      task: () => {
+        const subCliName = `@ones-open/cli-${projectCreatingParams.template}`;
+        return installSubCli({
+          subCliName,
+          root,
+          installLocalDependencies,
+          distTag
+        });
+      }
+    }];
+    const createProject = new Listr(projectCreatingTasks);
+    const externalTask = getExternalTaskByTemplateType(root, projectCreatingParams, {
+      ...options,
+      distTag
+    });
+    externalTask && createProject.add(externalTask);
+    await createProject.run(projectCreatingParams);
+    console.log(chalk.bold('\nProject has been created'), `\n${chalk.bold('Project path:')} ${chalk.green(root)}`, `\n${chalk.bold('Project name:')} ${chalk.green(projectCreatingParams.name)}`, `\n${chalk.bold('Project type:')} ${chalk.green(projectCreatingParams.template)}`, `\n${chalk.bold('Project description:')} ${chalk.green(projectCreatingParams.description)}`, `\n${chalk.bold('Project sub CLI:')} ${chalk.green(`@ones-open/cli-${projectCreatingParams.template}`)}`);
+  } catch (error) {
+    console.error(chalk.red(error));
+    await printEnvironmentInfo();
+  }
+}
+
+const cliVersion = (await getCliVersionByMetaPath(import.meta.url)) || 'unknown';
+const ones = new Command('ones');
+const gray = chalk.gray;
+ones.version(cliVersion, '-v, --version', 'output the current version');
+ones.command('create [project-name]').description(`create project from preset project template by type
+    ${gray(`
+    Tip: if you leave the [project-name] blank and
+    1. not specified the specific path, then will use current folder name as default project name
+    2. the specific path is also specified, then will use the folder name as default project name
+    `)}`).option('-d, --use-default-preset', 'skip prompts and use default preset').option('-s, --specific-path <path>', 'create at a specific path, it will automatically detect relative or absolute path').option('--plugin-type [type]', 'support type: team, organization', 'team').option('--policy <policy>', 'support policy: simple, standard', 'simple').addOption(new Option('-t, --project-type <type>', 'the type of project template, support: monorepo, plugin').default('plugin').hideHelp(true)).addOption(new Option('--install-local-dependencies', 'development only, install local dependencies after create project').hideHelp(true)).addOption(new Option('--dist-tag <tag>', 'specify the dist tag of sub CLI dependencies, default: latest').hideHelp(true)).addOption(new Option('--ones-version <onesVersion>', 'specify the version of ONES')).action(createProject);
+ones.command('envinfo').description('print environment info').action(printEnvironmentInfo);
+ones.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ones-open/cli",
-  "version": "2.1.0",
+  "version": "2.1.1",
   "description": "Command line interface for developers",
   "bin": {
     "ones": "./bin/index.es.js"
@@ -40,8 +40,8 @@
     "access": "public"
   },
   "dependencies": {
-    "@ones-open/cli-plugin": "^2.1.0",
-    "@ones-open/cli-utils": "^2.1.0",
+    "@ones-open/cli-plugin": "^2.1.1",
+    "@ones-open/cli-utils": "^2.1.1",
     "chalk": "~5.0.1",
     "commander": "~9.4.0",
     "envinfo": "~7.8.1",
@@ -56,5 +56,5 @@
     "@types/listr": "^0.14.4"
   },
   "type": "module",
-  "gitHead": "a15f5cf783067b23ff384818c3270eabc8675d5c"
+  "gitHead": "1e51d94a7a0362a4d26958a4f47b116914e12e5f"
 }