@loopback/cli 4.0.0-alpha.9 → 4.0.0

package/lib/debug.js

@@ -0,0 +1,16 @@
+// Copyright IBM Corp. 2018,2020. All Rights Reserved.
+// Node module: @loopback/cli
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+const debug = require('debug');
+
+/**
+ * Returns a debug function whose prefix is automatically scoped to
+ * "loopback:cli:{scope}". If no scope is provided, it will be scoped
+ * to "loopback:cli".
+ * @param {String=} scope The scope to use for the debug statement.
+ */
+module.exports = function (scope) {
+  return debug(`loopback:cli${scope ? `:${scope}` : ''}`);
+};

package/lib/globalize.js

@@ -0,0 +1,12 @@
+// Copyright IBM Corp. 2020. All Rights Reserved.
+// Node module: @loopback/cli
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+'use strict';
+
+const path = require('path');
+const SG = require('strong-globalize');
+
+SG.SetRootDir(path.join(__dirname, '..'), {autonomousMsgLoading: 'all'});
+module.exports = SG();

package/lib/model-discoverer.js

@@ -0,0 +1,118 @@
+// Copyright IBM Corp. 2019,2020. All Rights Reserved.
+// Node module: @loopback/cli
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+const debug = require('./debug')('model-discoverer');
+const fs = require('fs');
+const path = require('path');
+const {stringifyObject} = require('../lib/utils');
+
+/**
+ * Given a datasource and discovery options,
+ * return a list of objects {table: 'foo', schema: 'bar}
+ */
+async function discoverModelNames(ds, options) {
+  if (!ds.connected) {
+    await new Promise(resolve => {
+      ds.on('connected', resolve);
+    });
+  }
+  return ds.discoverModelDefinitions(options);
+}
+
+/**
+ * Returns the schema definition for a model
+ * @param ds - {Juggler.DataSource}
+ * @param modelName - {string}
+ * @param options - {object}
+ * @returns {Promise<Juggler.SchemaDefinition>}
+ */
+async function discoverSingleModel(ds, modelName, options) {
+  const schema = await ds.discoverSchema(modelName, options);
+  if (schema) {
+    schema.settings = schema && schema.options;
+  }
+  return schema;
+}
+
+/**
+ * Loads a DataSource from a file
+ * If the path provided is a JSON, it instantiates a juggler.DataSource with the config as the only argument
+ * Else it requires it like a compiled loopback datasource
+ * @param modulePath
+ * @returns juggler.DataSource
+ */
+function loadDataSource(modulePath) {
+  const ds = require(modulePath);
+  const key = Object.keys(ds)[0];
+  const val = new ds[key]();
+  return val;
+}
+
+/**
+ * Loads a compiled loopback datasource by name
+ * @param name - {string}
+ * @returns {*}
+ */
+function loadDataSourceByName(name) {
+  debug(`Searching for specified dataSource ${name}`);
+  const dataSourceFiles = getAllDataSourceFiles();
+  debug(`Loaded ${dataSourceFiles.length} dataSource files`);
+
+  // eslint-disable-next-line @typescript-eslint/prefer-for-of
+  for (let i = 0; i < dataSourceFiles.length; i++) {
+    const f = dataSourceFiles[i];
+    const ds = loadDataSource(path.resolve(DEFAULT_DATASOURCE_DIRECTORY, f));
+    if (ds.name === name) {
+      debug(`Found dataSource ${name}`);
+      return ds;
+    } else {
+      debug(`Did not match dataSource ${name} !== ${ds.name}`);
+    }
+  }
+  throw new Error(
+    `Cannot find datasource "${name}" in ${DEFAULT_DATASOURCE_DIRECTORY}`,
+  );
+}
+
+const DEFAULT_DATASOURCE_DIRECTORY = './dist/datasources';
+
+const MODEL_TEMPLATE_PATH = path.resolve(
+  __dirname,
+  '../generators/model/templates/model.ts.ejs',
+);
+
+const sanitizeProperty = function (o) {
+  Object.entries(o).forEach(([k, v]) => {
+    // Delete the null properties so the template doesn't spit out `key: ;`
+    if (v === null) {
+      delete o[k];
+    }
+
+    // If you are an object or array, stringify so you don't appear as [object [object]
+    if (typeof v === 'object' && v !== null) {
+      o[k] = stringifyObject(o[k], {
+        // don't break lines to avoid formatting problems in the model template
+        inlineCharacterLimit: Infinity,
+      });
+    }
+  });
+
+  o.tsType = o.type;
+};
+
+function getAllDataSourceFiles(dir = DEFAULT_DATASOURCE_DIRECTORY) {
+  return fs.readdirSync(dir).filter(s => s.endsWith('.datasource.js'));
+}
+
+module.exports = {
+  getAllDataSourceFiles,
+  sanitizeProperty,
+  discoverModelNames,
+  discoverSingleModel,
+  loadDataSource,
+  loadDataSourceByName,
+  DEFAULT_DATASOURCE_DIRECTORY,
+  MODEL_TEMPLATE_PATH,
+};

package/lib/project-generator.js

@@ -1,78 +1,130 @@
-// Copyright IBM Corp. 2017. All Rights Reserved.
+// Copyright IBM Corp. 2017,2020. All Rights Reserved.
 // Node module: @loopback/cli
 // This file is licensed under the MIT License.
 // License text available at https://opensource.org/licenses/MIT
 
 'use strict';
-const Generator = require('yeoman-generator');
-const path = require('path');
+
+const BaseGenerator = require('./base-generator');
 const utils = require('./utils');
+const chalk = require('chalk');
+const cliVersion = require('../package.json').version;
+const path = require('path');
+const g = require('./globalize');
 
-module.exports = class extends Generator {
+module.exports = class ProjectGenerator extends BaseGenerator {
   // Note: arguments and options should be defined in the constructor.
   constructor(args, opts) {
     super(args, opts);
-    this._setupGenerator();
+    // The default list of build options available for a project
+    // This list gets shown to users to let them select the appropriate
+    // build settings for their project.
+    this.buildOptions = [
+      {
+        name: 'eslint',
+        description: g.f('add a linter with pre-configured lint rules'),
+      },
+      {
+        name: 'prettier',
+        description: g.f('install prettier to format code conforming to rules'),
+      },
+      {
+        name: 'mocha',
+        description: g.f('install mocha to run tests'),
+      },
+      {
+        name: 'loopbackBuild',
+        description: g.f('use @loopback/build helpers (e.g. lb-eslint)'),
+      },
+      {name: 'vscode', description: g.f('add VSCode config files')},
+    ];
   }
 
   _setupGenerator() {
     this.argument('name', {
       type: String,
       required: false,
-      description: 'Project name for the ' + this.projectType,
+      description: g.f('Project name for the %s', this.projectType),
     });
 
     this.option('description', {
       type: String,
-      description: 'Description for the ' + this.projectType,
+      description: g.f('Description for the %s', this.projectType),
     });
 
     this.option('outdir', {
       type: String,
-      description: 'Project root directory for the ' + this.projectType,
+      description: g.f('Project root directory for the %s', this.projectType),
     });
 
-    this.option('tslint', {
+    this.option('eslint', {
       type: Boolean,
-      description: 'Enable tslint',
+      description: g.f('Enable eslint'),
     });
 
     this.option('prettier', {
       type: Boolean,
-      description: 'Enable prettier',
+      description: g.f('Enable prettier'),
     });
 
     this.option('mocha', {
       type: Boolean,
-      description: 'Enable mocha',
+      description: g.f('Enable mocha'),
     });
 
     this.option('loopbackBuild', {
       type: Boolean,
-      description: 'Use @loopback/build',
+      description: g.f('Use @loopback/build'),
+    });
+
+    this.option('vscode', {
+      type: Boolean,
+      description: g.f('Use preconfigured VSCode settings'),
+    });
+
+    this.option('private', {
+      type: Boolean,
+      description: g.f('Mark the project private (excluded from npm publish)'),
     });
+
+    this._setupRenameTransformer();
+    super._setupGenerator();
   }
 
   /**
-   * Override the usage text by replacing `yo loopback4:` with `lb4 `.
+   * Registers a Transform Stream with Yeoman. Removes `.ejs` extension
+   * from files that have it during project generation.
    */
-  usage() {
-    const text = super.usage();
-    return text.replace(/^yo loopback4:/g, 'lb4 ');
+  _setupRenameTransformer() {
+    this.registerTransformStream(utils.renameEJS());
   }
 
-  setOptions() {
-    this.projectInfo = {projectType: this.projectType};
-    [
+  async setOptions() {
+    await super.setOptions();
+    if (this.shouldExit()) return false;
+    if (this.options.name) {
+      const msg = utils.validate(this.options.name);
+      if (typeof msg === 'string') {
+        this.exit(msg);
+        return false;
+      }
+    }
+
+    this.projectInfo = {
+      projectType: this.projectType,
+      dependencies: utils.getDependencies(),
+    };
+    this.projectOptions = [
       'name',
       'description',
       'outdir',
-      'componentName',
-      'tslint',
-      'prettier',
-      'mocha',
-      'loopbackBuild',
-    ].forEach(n => {
+      'private',
+      'apiconnect',
+    ].concat(this.buildOptions);
+    this.projectOptions.forEach(n => {
+      if (typeof n === 'object') {
+        n = n.name;
+      }
       if (this.options[n]) {
         this.projectInfo[n] = this.options[n];
       }
@@ -80,18 +132,21 @@ module.exports = class extends Generator {
   }
 
   promptProjectName() {
+    if (this.shouldExit()) return false;
     const prompts = [
       {
         type: 'input',
         name: 'name',
-        message: 'Project name:',
+        message: g.f('Project name:'),
         when: this.projectInfo.name == null,
-        default: this.options.name || this.appname,
+        default:
+          this.options.name || utils.toFileName(path.basename(process.cwd())),
+        validate: utils.validate,
       },
       {
         type: 'input',
         name: 'description',
-        message: 'Project description:',
+        message: g.f('Project description:'),
         when: this.projectInfo.description == null,
         default: this.options.name || this.appname,
       },
@@ -103,16 +158,18 @@ module.exports = class extends Generator {
   }
 
   promptProjectDir() {
+    if (this.shouldExit()) return false;
     const prompts = [
       {
         type: 'input',
         name: 'outdir',
-        message: 'Project root directory:',
+        message: g.f('Project root directory:'),
         when:
           this.projectInfo.outdir == null ||
-          utils.validateyNotExisting(this.projectInfo.outdir) !== true,
-        validate: utils.validateyNotExisting,
-        default: this.projectInfo.name,
+          // prompts if option was set to a directory that already exists
+          utils.validateNotExisting(this.projectInfo.outdir) !== true,
+        validate: utils.validateNotExisting,
+        default: this.projectInfo.name && this.projectInfo.name.toLowerCase(),
       },
     ];
 
@@ -122,50 +179,86 @@ module.exports = class extends Generator {
   }
 
   promptOptions() {
+    if (this.shouldExit()) return false;
     const choices = [];
-    ['tslint', 'prettier', 'mocha', 'loopbackBuild'].forEach(f => {
-      if (!this.options[f]) {
+    this.buildOptions.forEach(f => {
+      if (this.options[f.name] == null) {
+        const name = g.f('Enable %s', f.name);
         choices.push({
-          name: 'Enable ' + f,
-          key: f,
+          name: `${name}: ${chalk.gray(f.description)}`,
+          key: f.name,
+          short: `Enable ${f.name}`,
           checked: true,
         });
+      } else {
+        this.projectInfo[f.name] = this.options[f.name];
       }
     });
     const prompts = [
       {
         name: 'settings',
-        message: 'Select project build settings: ',
+        message: g.f('Select features to enable in the project'),
         type: 'checkbox',
         choices: choices,
+        default: choices.map(c => c.short),
         // Skip if all features are enabled by cli options
         when: choices.length > 0,
       },
     ];
-    return this.prompt(prompts).then(props => {
-      const settings = props.settings || choices.map(c => c.name);
+    return this.prompt(prompts).then(({settings}) => {
       const features = choices.map(c => {
         return {
           key: c.key,
-          value: settings.indexOf(c.name) !== -1,
+          value:
+            settings.indexOf(c.name) !== -1 || settings.indexOf(c.short) !== -1,
         };
       });
       features.forEach(f => (this.projectInfo[f.key] = f.value));
     });
   }
 
+  promptYarnInstall() {
+    if (this.shouldExit()) return false;
+    const prompts = [
+      {
+        type: 'confirm',
+        name: 'yarn',
+        message: g.f('Yarn is available. Do you prefer to use it by default?'),
+        when: !this.options.packageManager && utils.isYarnAvailable(),
+        default: false,
+      },
+    ];
+
+    return this.prompt(prompts).then(props => {
+      if (props.yarn) {
+        this.options.packageManager = 'yarn';
+      }
+    });
+  }
+
   scaffold() {
+    if (this.shouldExit()) return false;
+
     this.destinationRoot(this.projectInfo.outdir);
 
+    // Store information for cli operation in .yo.rc.json
+    this.config.set('packageManager', this.options.packageManager || 'npm');
+    this.config.set('version', cliVersion);
+
     // First copy common files from ../../project/templates
-    this.fs.copyTpl(
+    this.copyTemplatedFiles(
       this.templatePath('../../project/templates/**/*'),
       this.destinationPath(''),
       {
         project: this.projectInfo,
+        packageManager: this.config.get('packageManager'),
+        author: this.user.git.email()
+          ? {
+              name: this.user.git.name(),
+              email: this.user.git.email(),
+            }
+          : null,
       },
-      {},
-      {globOptions: {dot: true}}
     );
 
     // Rename `_.gitignore` back to `.gitignore`.
@@ -173,22 +266,22 @@ module.exports = class extends Generator {
     // if it's there in the templates.
     this.fs.move(
       this.destinationPath('_.gitignore'),
-      this.destinationPath('.gitignore')
+      this.destinationPath('.gitignore'),
     );
 
     // Copy project type specific files from ./templates
-    this.fs.copyTpl(
+    this.copyTemplatedFiles(
       this.templatePath('**/*'),
       this.destinationPath(''),
       {
         project: this.projectInfo,
+        packageManager: this.config.get('packageManager'),
       },
-      {},
-      {globOptions: {dot: true}}
     );
 
-    if (!this.projectInfo.tslint) {
-      this.fs.delete(this.destinationPath('tslint.*json'));
+    if (!this.projectInfo.eslint) {
+      this.fs.delete(this.destinationPath('.eslintrc.*.ejs'));
+      this.fs.delete(this.destinationPath('.eslintignore'));
     }
 
     if (!this.projectInfo.prettier) {
@@ -197,19 +290,23 @@ module.exports = class extends Generator {
 
     if (!this.projectInfo.loopbackBuild) {
       this.fs.move(
-        this.destinationPath('package.plain.json'),
-        this.destinationPath('package.json')
+        this.destinationPath('package.plain.json.ejs'),
+        this.destinationPath('package.json.ejs'),
       );
     } else {
-      this.fs.delete(this.destinationPath('package.plain.json'));
+      this.fs.delete(this.destinationPath('package.plain.json.ejs'));
     }
 
     if (!this.projectInfo.mocha) {
-      this.fs.delete(this.destinationPath('test/mocha.opts'));
+      this.fs.delete(this.destinationPath('.mocharc.json'));
     }
-  }
 
-  install() {
-    this.npmInstall(null, {}, {cwd: this.destinationRoot()});
+    if (!this.projectInfo.vscode) {
+      this.fs.delete(this.destinationPath('.vscode'));
+    }
+
+    if (this.options.packageManager === 'yarn') {
+      this.fs.delete(this.destinationPath('.npmrc'));
+    }
   }
 };

package/lib/tab-completion.js

@@ -0,0 +1,127 @@
+// Copyright IBM Corp. 2020. All Rights Reserved.
+// Node module: @loopback/cli
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+'use strict';
+
+const debug = require('./debug')();
+const tabtab = require('tabtab');
+
+const tabCompletionCommands = [
+  'install-completion',
+  'uninstall-completion',
+  'completion',
+];
+
+/**
+ * Get all available commands or options depends on entered input
+ * @param optionsAndArgs - object of available options and arguments
+ * - name - generator name
+ * - options - list of option objects
+ * - arguments - list of argument objects
+ * @param partial - completion env.partial
+ */
+function generateCompletions(optionsAndArgs, partial) {
+  // Remove the `base`
+  delete optionsAndArgs.base;
+  const commands = Object.keys(optionsAndArgs);
+  const enteredCommand = commands.find(command => partial.includes(command));
+
+  if (!enteredCommand) {
+    return commands;
+  }
+
+  const options = optionsAndArgs[enteredCommand].options;
+  const optionNames = Object.keys(options).map(opt => `--${opt}`);
+
+  const enteredOptions = optionNames.filter(opt => partial.includes(opt));
+
+  if (!enteredOptions.length) {
+    return optionNames;
+  }
+
+  return optionNames.filter(opt => !enteredOptions.includes(opt));
+}
+
+/**
+ * Process bash-completion and take care about logging available commands
+ * and options
+ * @param optionsAndArgs - object of available options and arguments
+ * - name - generator name
+ * - options - list of option objects
+ * - arguments - list of argument objects
+ * @param env - completion environment object
+ * - complete    A Boolean indicating whether we act in "plumbing mode" or not
+ * - words       The Number of words in the completed line
+ * - point       A Number indicating cursor position
+ * - line        The String input line
+ * - partial     The String part of line preceding cursor position
+ * - last        The last String word of the line
+ * - lastPartial The last word String of partial
+ * - prev        The String word preceding last
+ */
+function completion(optionsAndArgs, env) {
+  if (!env.complete) {
+    return;
+  }
+
+  return tabtab.log(generateCompletions(optionsAndArgs, env.partial));
+}
+
+/**
+ * Register tabtab completion script
+ * Will be written in bashrc or zshrc or fish configs
+ */
+async function installTabCompletionScript() {
+  try {
+    await tabtab.install({
+      name: 'lb4',
+      completer: 'lb4',
+    });
+  } catch (error) /* istanbul ignore next */ {
+    debug('tab completion install script');
+    throw error;
+  }
+}
+
+/**
+ * Remove tabtab completion script
+ * Will be removed from bashrc or zshrc or fish configs
+ */
+async function uninstallTabCompletionScript() {
+  try {
+    await tabtab.uninstall({
+      name: 'lb4',
+    });
+  } catch (error) /* istanbul ignore next */ {
+    debug('tab completion uninstall script');
+    throw error;
+  }
+}
+
+/**
+ * Run corresponding tab-completion command
+ * @param optionsAndArgs - object of available options and arguments
+ * - name - generator name
+ * - options - list of option objects
+ * - arguments - list of argument objects
+ * @param originalCommand - command name
+ * @param log - Log function
+ */
+function runTabCompletionCommand(optionsAndArgs, originalCommand, log) {
+  if (originalCommand === 'install-completion') {
+    return installTabCompletionScript().catch(log);
+  }
+
+  if (originalCommand === 'uninstall-completion') {
+    return uninstallTabCompletionScript().catch(log);
+  }
+
+  return completion(optionsAndArgs, tabtab.parseEnv(process.env));
+}
+
+exports.tabCompletionCommands = tabCompletionCommands;
+exports.runTabCompletionCommand = runTabCompletionCommand;
+
+exports.generateCompletions = generateCompletions;

package/lib/update-index.js

@@ -0,0 +1,44 @@
+// Copyright IBM Corp. 2018,2020. All Rights Reserved.
+// Node module: @loopback/cli
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+const debug = require('./debug')('update-index');
+
+const path = require('path');
+const fse = require('fs-extra');
+const defaultFs = {
+  read: fse.readFile,
+  write: fse.writeFile,
+  append: fse.appendFile,
+  exists: fse.exists,
+};
+
+/**
+ *
+ * @param {String} dir The directory in which index.ts is to be updated/created
+ * @param {*} file The new file to be exported from index.ts
+ */
+module.exports = async function (dir, file, fsApis) {
+  const {read, write, append, exists} = {...defaultFs, ...fsApis};
+  debug(`Updating index with ${path.join(dir, file)}`);
+  const indexFile = path.join(dir, 'index.ts');
+  if (!file.endsWith('.ts')) {
+    throw new Error(`${file} must be a TypeScript (.ts) file`);
+  }
+
+  let index = '';
+  const indexExists = await exists(indexFile);
+  if (indexExists) {
+    index = await read(indexFile);
+  }
+  const content = `export * from './${file.slice(0, -3)}';\n`;
+  if (!index.includes(content)) {
+    if (indexExists) {
+      await append(indexFile, content);
+    } else {
+      await fse.ensureDir(dir);
+      await write(indexFile, content);
+    }
+  }
+};