@loopback/cli 4.0.0-alpha.9 → 4.1.1

package/generators/copyright/index.js

@@ -0,0 +1,230 @@
+// Copyright IBM Corp. and LoopBack contributors 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 BaseGenerator = require('../../lib/base-generator');
+const {updateFileHeaders} = require('./header');
+const {spdxLicenseList, updateLicense} = require('./license');
+const g = require('../../lib/globalize');
+const _ = require('lodash');
+const chalk = require('chalk');
+const autocomplete = require('inquirer-autocomplete-prompt');
+
+module.exports = class CopyrightGenerator extends BaseGenerator {
+  // Note: arguments and options should be defined in the constructor.
+  constructor(args, opts) {
+    super(args, opts);
+    this.licenseList = [];
+    for (const id in spdxLicenseList) {
+      const license = spdxLicenseList[id];
+      if (
+        ['mit', 'apache-2.0', 'isc', 'artistic-2.0', 'custom'].includes(
+          id.toLocaleLowerCase(),
+        )
+      ) {
+        // Add well-known licenses in front of the list
+        this.licenseList.unshift(license);
+      } else {
+        this.licenseList.push(license);
+      }
+    }
+    this.licenseList = this.licenseList.map(lic => ({
+      value: lic,
+      name: `${lic.id} (${lic.name})`,
+    }));
+  }
+
+  initializing() {
+    // Register `autocomplete` plugin
+    this.env.adapter.promptModule.registerPrompt('autocomplete', autocomplete);
+  }
+
+  _setupGenerator() {
+    this.option('owner', {
+      type: String,
+      required: false,
+      description: g.f('Copyright owner'),
+    });
+    this.option('license', {
+      type: String,
+      required: false,
+      description: g.f('License'),
+    });
+    this.option('updateLicense', {
+      type: Boolean,
+      required: false,
+      description: g.f('Update license in package.json and LICENSE'),
+    });
+    this.option('gitOnly', {
+      type: Boolean,
+      required: false,
+      default: true,
+      description: g.f('Only update git tracked files'),
+    });
+    this.option('exclude', {
+      type: String,
+      required: false,
+      default: '',
+      description: g.f('Exclude files that match the pattern'),
+    });
+  }
+
+  setOptions() {
+    return super.setOptions();
+  }
+
+  async promptOwnerAndLicense() {
+    const pkgFile = this.destinationPath('package.json');
+    const pkg = this.fs.readJSON(this.destinationPath('package.json'));
+    if (pkg == null) {
+      this.exit(`${pkgFile} does not exist.`);
+      return;
+    }
+    this.packageJson = pkg;
+    let author = _.get(pkg, 'author');
+    if (typeof author === 'object') {
+      author = author.name;
+    }
+    const owner =
+      this.options.copyrightOwner || _.get(pkg, 'copyright.owner', author);
+    let license = this.options.license || _.get(pkg, 'license');
+    const licenses = [...this.licenseList];
+    if (license != null) {
+      // find the matching license by id and move it to the front of the list
+      for (let i = 0; i < licenses.length; i++) {
+        if (licenses[i].value.id.toLowerCase() === license.toLowerCase()) {
+          const lic = licenses.splice(i, 1);
+          licenses.unshift(...lic);
+          break;
+        }
+      }
+    }
+
+    let answers = await this.prompt([
+      {
+        type: 'input',
+        name: 'owner',
+        message: g.f('Copyright owner:'),
+        default: owner,
+        when: this.options.owner == null,
+      },
+      {
+        type: 'autocomplete',
+        name: 'license',
+        // choices: licenseList,
+        source: async (_answers, input) => {
+          if (input == null) return licenses;
+          const matched = licenses.filter(lic => {
+            const a = input.toLowerCase();
+            return (
+              lic.value.id.toLowerCase().startsWith(a) ||
+              lic.value.name.toLowerCase().startsWith(a)
+            );
+          });
+          return matched;
+        },
+        pageSize: 10,
+        message: g.f('License name:'),
+        default: license,
+        when: this.options.license == null,
+      },
+    ]);
+    answers = answers || {};
+    const exclude = this.options.exclude || '';
+    const excludePatterns = exclude.split(',').filter(p => p !== '');
+    excludePatterns.push('**/node_modules/**/*');
+
+    const copyrightOwner = answers.owner || this.options.owner;
+    license = answers.license || this.options.license;
+
+    let customLicenseLines = [];
+    if (
+      (license && license.id === 'CUSTOM') ||
+      license === 'custom' ||
+      license === 'CUSTOM'
+    ) {
+      const templateFile = this.destinationPath('license-header.template');
+      if (this.fs.exists(templateFile)) {
+        const template = this.fs.read(templateFile);
+        customLicenseLines = template.match(/[^\r\n]+/g);
+        this.log(template);
+      } else {
+        this.log(
+          g.f(
+            'Please provide lines of text for the custom copyright/license headers.',
+          ),
+        );
+        const example = ` Copyright <%= owner %> <%= years %>. All Rights Reserved.
+ Node module: <%= name %>',
+ This file is licensed under the <%= license %>.
+ License text available at <%= url %>`;
+        this.log(
+          chalk.green(
+            `Example (supported variables: owner/years/name):
+${example}`,
+          ),
+        );
+
+        answers = await this.prompt([
+          {
+            type: 'editor',
+            name: 'customLicenseLines',
+            message: g.f('Custom license lines:'),
+            default: example,
+            when: customLicenseLines.length === 0,
+          },
+        ]);
+      }
+    }
+
+    answers = answers || {};
+    if (answers.customLicenseLines) {
+      customLicenseLines = answers.customLicenseLines;
+      this.log(customLicenseLines);
+      customLicenseLines = customLicenseLines.match(/[^\r\n]+/g);
+    }
+
+    this.headerOptions = {
+      copyrightOwner,
+      customLicenseLines,
+      license,
+      log: this.log,
+      gitOnly: this.options.gitOnly,
+      fs: this.fs,
+      excludePatterns,
+    };
+  }
+
+  async updateLicense() {
+    if (this.shouldExit()) return;
+    const answers = await this.prompt([
+      {
+        type: 'confirm',
+        name: 'updateLicense',
+        message: g.f('Do you want to update package.json and LICENSE?'),
+        default: false,
+        when: this.options.updateLicense == null,
+      },
+    ]);
+    const updateLicenseFile =
+      (answers && answers.updateLicense) || this.options.updateLicense;
+    if (!updateLicenseFile) return;
+    this.headerOptions.updateLicense = updateLicenseFile;
+    await updateLicense(
+      this.destinationRoot(),
+      this.packageJson,
+      this.headerOptions,
+    );
+  }
+
+  async updateHeaders() {
+    if (this.shouldExit()) return;
+    await updateFileHeaders(this.destinationRoot(), this.headerOptions);
+  }
+
+  async end() {
+    await super.end();
+  }
+};

package/generators/copyright/license.js

@@ -0,0 +1,105 @@
+// Copyright IBM Corp. and LoopBack contributors 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 path = require('path');
+const {FSE} = require('./fs');
+const {getYears} = require('./git');
+const {wrapText} = require('../../lib/utils');
+const spdxLicenses = require('spdx-license-list/full');
+
+spdxLicenses.CUSTOM = {
+  name: 'Custom License',
+  url: '',
+  osiApproved: false,
+  licenseText: '',
+};
+
+const spdxLicenseList = {};
+for (const id in spdxLicenses) {
+  spdxLicenseList[id.toLowerCase()] = {id, ...spdxLicenses[id]};
+}
+
+/**
+ * Render license text
+ * @param name - Module name
+ * @param owner - Copyright owner
+ * @param years - Years of update
+ * @param license - License object
+ */
+function renderLicense({name, owner, years, license}) {
+  if (typeof license === 'string') {
+    license = spdxLicenseList[license.toLowerCase()];
+  }
+  let text = replaceCopyRight(license.licenseText, {owner, years});
+  text = wrapText(text, 80);
+  return `Copyright (c) ${owner} ${years}.
+Node module: ${name}
+This project is licensed under the ${license.name}, full text below.
+
+--------
+
+${text}
+`;
+  /*
+Copyright (c) IBM Corp. and LoopBack contributors 2018,2019. All Rights Reserved.
+Node module: @loopback/boot
+This project is licensed under the MIT License, full text below.
+
+--------
+
+MIT license
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+}
+
+function replaceCopyRight(text, {owner, years}) {
+  // Copyright (c) <YEAR> <COPYRIGHT HOLDERS>
+  return text.replace(
+    /Copyright \(c\) <[^<>]+> <[^<>]+>/gi,
+    `Copyright (c) ${owner} ${years}`,
+  );
+}
+
+async function updateLicense(projectRoot, pkg, options) {
+  if (!options.updateLicense) return;
+  const fs = options.fs || FSE;
+  let licenseId = options.license;
+  if (typeof licenseId === 'object') {
+    licenseId = licenseId.id;
+  }
+  pkg.license = licenseId;
+  pkg['copyright.owner'] = options.copyrightOwner;
+  await fs.writeJSON(path.join(projectRoot, 'package.json'), pkg);
+  await fs.write(
+    path.join(projectRoot, 'LICENSE'),
+    renderLicense({
+      name: pkg.name,
+      owner: options.copyrightOwner,
+      license: options.license,
+      years: await getYears(projectRoot),
+    }),
+  );
+}
+
+exports.renderLicense = renderLicense;
+exports.spdxLicenseList = spdxLicenseList;
+exports.updateLicense = updateLicense;

package/generators/datasource/index.js

@@ -0,0 +1,341 @@
+// Copyright IBM Corp. and LoopBack contributors 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
+
+// no translation: Datasource
+'use strict';
+
+const ArtifactGenerator = require('../../lib/artifact-generator');
+const debug = require('../../lib/debug')('datasource-generator');
+const chalk = require('chalk');
+const path = require('path');
+const utils = require('../../lib/utils');
+const connectors = require('../../lib/connectors.json');
+const g = require('../../lib/globalize');
+
+/**
+ * DataSource Generator -- CLI
+ *
+ * Prompts for a name, connector and connector options. Creates json file
+ * for the DataSource as well as a Class for a user to modify. Also installs the
+ * appropriate connector from npm.
+ */
+module.exports = class DataSourceGenerator extends ArtifactGenerator {
+  constructor(args, opts) {
+    super(args, opts);
+  }
+
+  _setupGenerator() {
+    this.artifactInfo = {
+      type: 'datasource',
+      rootDir: 'src',
+    };
+
+    // Datasources are stored in the datasources directory
+    this.artifactInfo.outDir = path.resolve(
+      this.artifactInfo.rootDir,
+      'datasources',
+    );
+
+    const connectorChoices = [];
+    /**
+     * Creating a list of connectors -- and marking them as either supported by
+     * StrongLoop or community.
+     */
+    Object.values(connectors).forEach(connector => {
+      const support = connector.supportedByStrongLoop
+        ? '(supported by StrongLoop)'
+        : '(provided by community)';
+      connectorChoices.push({
+        name: `${connector.description} ${chalk.gray(support)}`,
+        value: connector.name,
+      });
+    });
+
+    this.connectorChoices = connectorChoices;
+    // Add `other` so users can add a connector that isn't part of the list
+    // Though it can be added by creating a PR and adding it to
+    // connectors.json
+    this.connectorChoices.push('other');
+
+    return super._setupGenerator();
+  }
+
+  setOptions() {
+    return super.setOptions();
+  }
+
+  /**
+   * Ensure CLI is being run in a LoopBack 4 project.
+   */
+  checkLoopBackProject() {
+    if (this.shouldExit()) return;
+    return super.checkLoopBackProject();
+  }
+
+  /**
+   * Ask for DataSource Name -- Must be unique
+   */
+  promptArtifactName() {
+    debug('Prompting for artifact name');
+    if (this.shouldExit()) return false;
+
+    if (this.artifactInfo.name) {
+      return;
+    }
+
+    const prompts = [
+      {
+        type: 'input',
+        name: 'name',
+        // capitalization
+        message: g.f('%s name:', utils.toClassName(this.artifactInfo.type)),
+        when: this.artifactInfo.name === undefined,
+        validate: utils.validateClassName,
+      },
+    ];
+
+    return this.prompt(prompts).then(props => {
+      Object.assign(this.artifactInfo, props);
+      return props;
+    });
+  }
+
+  /**
+   * Ask the user to select the connector for the DataSource
+   */
+  promptConnector() {
+    debug('prompting for datasource connector');
+    if (this.shouldExit()) return;
+    const prompts = [
+      {
+        name: 'connector',
+        message: g.f(
+          'Select the connector for %s: ',
+          chalk.yellow(this.artifactInfo.name),
+        ),
+        type: 'list',
+        default: 'memory',
+        choices: this.connectorChoices,
+        when: this.artifactInfo.connector === undefined,
+      },
+    ];
+
+    return this.prompt(prompts).then(props => {
+      Object.assign(this.artifactInfo, props);
+      return props;
+    });
+  }
+
+  /**
+   * If the user selected `other` for connector -- ask the user to provide
+   * `npm` module name for the connector.
+   */
+  promptCustomConnectorInfo() {
+    if (this.shouldExit()) return;
+    if (this.artifactInfo.connector !== 'other') {
+      debug('custom connector option was not selected');
+      return;
+    } else {
+      debug('prompting for custom connector');
+      const prompts = [
+        {
+          name: 'customConnector',
+          message: g.f("Enter the connector's package name:"),
+          validate: utils.validate,
+        },
+      ];
+
+      return this.prompt(prompts).then(props => {
+        this.artifactInfo.connector = props.customConnector;
+        return props;
+      });
+    }
+  }
+
+  /**
+   * Prompt the user for connector specific settings -- only applies to
+   * connectors in the connectors.json list
+   */
+  promptConnectorConfig() {
+    debug('prompting for connector config');
+    if (this.shouldExit()) return;
+    // Check to make sure connector is from connectors list (not custom)
+    const settings =
+      (connectors[this.artifactInfo.connector] &&
+        connectors[this.artifactInfo.connector]['settings']) ||
+      {};
+    const prompts = [];
+
+    // Create list of questions to prompt the user
+    Object.entries(settings).forEach(([key, setting]) => {
+      // Set defaults and merge with `setting` to override properties
+      const question = Object.assign(
+        {},
+        {name: key, message: key, suffix: ':', default: null},
+        setting,
+      );
+
+      /**
+       * Allowed Types: string, number, password, object, array, boolean
+       * Must be converted to inquirer types -- input, confirm, password
+       */
+      switch ((setting.type || '').toLowerCase()) {
+        case 'string':
+        case 'number':
+          question.type = 'input';
+          break;
+        case 'object':
+        case 'array':
+          question.type = 'input';
+          question.validate = utils.validateStringObject(setting.type);
+          break;
+        case 'boolean':
+          question.type = 'confirm';
+          break;
+        case 'password':
+          break;
+        default:
+          console.warn(
+            g.f(
+              'Using default input of type input for setting %s as %s is not supported',
+              key,
+              setting.type || undefined,
+            ),
+          );
+          // Default to input type
+          question.type = 'input';
+      }
+
+      prompts.push(question);
+    });
+
+    debug(`connector setting questions - ${JSON.stringify(prompts)}`);
+
+    // If no prompts, we need to return instead of attempting to ask prompts
+    if (!prompts.length) return;
+
+    debug('prompting the user - length > 0 for questions');
+    // Ask user for prompts
+    return this.prompt(prompts).then(props => {
+      // Convert user inputs to correct types
+      Object.entries(settings).forEach(([key, setting]) => {
+        switch ((setting.type || '').toLowerCase()) {
+          case 'number':
+            props[key] = Number(props[key]);
+            break;
+          case 'array':
+          case 'object':
+            if (props[key] == null || props[key] === '') {
+              delete props[key];
+            } else {
+              props[key] = JSON.parse(props[key]);
+            }
+            break;
+        }
+      });
+      this.artifactInfo = Object.assign(this.artifactInfo, {settings: props});
+    });
+  }
+
+  /**
+   * Scaffold DataSource related files
+   * super.scaffold() doesn't provide a way to rename files -- don't call it
+   */
+  scaffold() {
+    // Exit if needed
+    if (this.shouldExit()) return false;
+
+    // Setting up data for templates
+    this.artifactInfo.className = utils.toClassName(this.artifactInfo.name);
+    this.artifactInfo.fileName = utils.toFileName(this.artifactInfo.name);
+    // prettier-ignore
+    this.artifactInfo.outFile = `${this.artifactInfo.fileName}.datasource.ts`;
+
+    // Resolved Output Paths.
+    const tsPath = this.destinationPath(
+      this.artifactInfo.outDir,
+      this.artifactInfo.outFile,
+    );
+
+    // template path
+    const classTemplatePath = this.templatePath('datasource.ts.ejs');
+
+    // Debug Info
+    debug(`this.artifactInfo.name => ${this.artifactInfo.name}`);
+    debug(`this.artifactInfo.className => ${this.artifactInfo.className}`);
+    debug(`this.artifactInfo.fileName => ${this.artifactInfo.fileName}`);
+    debug(`this.artifactInfo.outFile => ${this.artifactInfo.outFile}`);
+    debug(`tsPath => ${tsPath}`);
+
+    // Data to save to DataSource JSON file
+    const dsConfig = Object.assign(
+      {name: this.artifactInfo.name, connector: this.artifactInfo.connector},
+      this.artifactInfo.settings,
+    );
+
+    // From LB3
+    if (dsConfig.connector === 'ibm-object-storage') {
+      dsConfig.connector = 'loopback-component-storage';
+      dsConfig.provider = 'openstack';
+      dsConfig.useServiceCatalog = true;
+      dsConfig.useInternal = false;
+      dsConfig.keystoneAuthVersion = 'v3';
+    }
+
+    this.artifactInfo.dsConfigString = utils.stringifyObject(dsConfig, {
+      // Prevent inlining the config into a single line, e.g.
+      // const config = {name: 'db', connector: 'memory'};
+      inlineCharacterLimit: 0,
+    });
+    debug(`datasource configuration code: ${this.artifactInfo.dsConfigString}`);
+
+    this.copyTemplatedFiles(classTemplatePath, tsPath, this.artifactInfo);
+  }
+
+  install() {
+    if (this.shouldExit()) return false;
+    debug('install npm dependencies');
+    const pkgJson = this.packageJson || {};
+    const deps = pkgJson.dependencies || {};
+    const pkgs = [];
+
+    // Connector package.
+    const connector = connectors[this.artifactInfo.connector];
+    if (connector && connector.package) {
+      if (!deps[connector.package.name]) {
+        pkgs.push(
+          connector.package.name +
+            `${
+              connector.package.version ? '@' + connector.package.version : ''
+            }`,
+        );
+      }
+
+      debug(`npmModule - ${pkgs[0]}`);
+    } else {
+      const connectorName = this.artifactInfo.connector;
+      // Other connectors that are not listed in `connectors.json`.
+      // No install is needed for those in connectors.json but without a
+      // package name as they are built-in connectors
+      if (!deps[connectorName] && !connector) pkgs.push(connectorName);
+    }
+
+    if (!deps['@loopback/repository']) {
+      pkgs.push('@loopback/repository');
+    }
+
+    if (pkgs.length === 0) return;
+
+    this.pkgManagerInstall(pkgs, {
+      npm: {
+        save: true,
+      },
+    });
+  }
+
+  async end() {
+    await super.end();
+  }
+};

package/generators/datasource/templates/datasource.ts.ejs

@@ -0,0 +1,22 @@
+import {inject, lifeCycleObserver, LifeCycleObserver} from '@loopback/core';
+import {juggler} from '@loopback/repository';
+
+const config = <%- dsConfigString %>;
+
+// Observe application's life cycle to disconnect the datasource when
+// application is stopped. This allows the application to be shut down
+// gracefully. The `stop()` method is inherited from `juggler.DataSource`.
+// Learn more at https://loopback.io/doc/en/lb4/Life-cycle.html
+@lifeCycleObserver('datasource')
+export class <%= className %>DataSource extends juggler.DataSource
+  implements LifeCycleObserver {
+  static dataSourceName = '<%= name %>';
+  static readonly defaultConfig = config;
+
+  constructor(
+    @inject('datasources.config.<%= name %>', {optional: true})
+    dsConfig: object = config,
+  ) {
+    super(dsConfig);
+  }
+}