@loopback/cli 4.0.0-alpha.8 → 4.1.0

package/generators/discover/import-discovered-model.js

@@ -0,0 +1,70 @@
+// Copyright IBM Corp. and LoopBack contributors 2019. 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 {pascalCase, stringifyModelSettings} = require('../../lib/utils');
+const {sanitizeProperty} = require('../../lib/model-discoverer');
+const {
+  createPropertyTemplateData,
+  findBuiltinType,
+} = require('../model/property-definition');
+
+module.exports = {
+  importDiscoveredModel,
+};
+
+/**
+ * Convert model definition created by loopback-datasource-juggler discovery
+ * into template data used by LB4 model generator.
+ *
+ * @param {object} discoveredDefinition Model definition as discovered from DB
+ * @returns {object} Template data for model source file template
+ */
+function importDiscoveredModel(discoveredDefinition) {
+  const modelName = discoveredDefinition.name;
+  const templateData = {
+    name: modelName,
+    className: pascalCase(modelName),
+    modelBaseClass: 'Entity',
+    isModelBaseBuiltin: true,
+    settings: importModelSettings(discoveredDefinition.settings),
+    properties: importModelProperties(discoveredDefinition.properties),
+    allowAdditionalProperties: true,
+  };
+
+  templateData.modelSettings = stringifyModelSettings(templateData.settings);
+
+  return templateData;
+}
+
+function importModelSettings(discoveredSettings = {}) {
+  // Currently a no-op, we may want to apply transformation in the future
+  // See migrateModelSettings in ../import-lb3-models/migrate-model.js
+  return {
+    // Shallow-clone to avoid accidental modification of input data
+    ...discoveredSettings,
+  };
+}
+
+function importModelProperties(discoveredProps) {
+  const templateData = {};
+  for (const prop in discoveredProps) {
+    templateData[prop] = importPropertyDefinition(discoveredProps[prop]);
+  }
+  return templateData;
+}
+
+function importPropertyDefinition(discoveredDefinition) {
+  const propDef = {
+    ...discoveredDefinition,
+  };
+
+  const builtinType = findBuiltinType(propDef.type);
+  if (builtinType) propDef.type = builtinType;
+
+  sanitizeProperty(propDef);
+  return createPropertyTemplateData(propDef);
+}

package/generators/discover/index.js

@@ -0,0 +1,411 @@
+// Copyright IBM Corp. and LoopBack contributors 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 path = require('path');
+const ArtifactGenerator = require('../../lib/artifact-generator');
+const modelMaker = require('../../lib/model-discoverer');
+const debug = require('../../lib/debug')('discover-generator');
+const chalk = require('chalk');
+const utils = require('../../lib/utils');
+const modelDiscoverer = require('../../lib/model-discoverer');
+const {importDiscoveredModel} = require('./import-discovered-model');
+const g = require('../../lib/globalize');
+
+const rootDir = 'src';
+
+module.exports = class DiscoveryGenerator extends ArtifactGenerator {
+  constructor(args, opts) {
+    super(args, opts);
+
+    this.option('dataSource', {
+      type: String,
+      alias: 'ds',
+      description: g.f('The name of the datasource to discover'),
+    });
+
+    this.option('views', {
+      type: Boolean,
+      description: g.f('Boolean to discover views'),
+      default: true,
+    });
+
+    this.option('relations', {
+      type: Boolean,
+      description: g.f('Discover and create relations'),
+      default: false,
+    });
+
+    this.option('schema', {
+      type: String,
+      description: g.f('Schema to discover'),
+      default: '',
+    });
+
+    this.option('all', {
+      type: Boolean,
+      description: g.f('Discover all models without prompting users to select'),
+      default: false,
+    });
+
+    this.option('outDir', {
+      type: String,
+      description: g.f(
+        'Specify the directory into which the `model.model.ts` files will be placed',
+      ),
+      default: undefined,
+    });
+
+    this.option('optionalId', {
+      type: Boolean,
+      description: g.f('Boolean to mark id property as optional field'),
+      default: false,
+    });
+  }
+
+  _setupGenerator() {
+    this.artifactInfo = {
+      type: 'discover',
+      rootDir,
+      outDir: path.resolve(rootDir, 'models'),
+    };
+
+    return super._setupGenerator();
+  }
+
+  /**
+   * If we have a dataSource, attempt to load it
+   * @returns {*}
+   */
+  setOptions() {
+    /* istanbul ignore next */
+    if (this.options.dataSource) {
+      debug(`Data source specified: ${this.options.dataSource}`);
+      this.artifactInfo.dataSource = modelMaker.loadDataSourceByName(
+        this.options.dataSource,
+      );
+    }
+
+    return super.setOptions();
+  }
+
+  /**
+   * Ensure CLI is being run in a LoopBack 4 project.
+   */
+  checkLoopBackProject() {
+    /* istanbul ignore next */
+    if (this.shouldExit()) return;
+    return super.checkLoopBackProject();
+  }
+
+  /**
+   * Loads all datasources to choose if the dataSource option isn't set
+   */
+  async loadAllDatasources() {
+    // If we have a dataSourcePath then it is already loaded for us, we don't need load any
+    /* istanbul ignore next */
+    if (this.artifactInfo.dataSource) {
+      return;
+    }
+    const dsDir = modelMaker.DEFAULT_DATASOURCE_DIRECTORY;
+    const datasourcesList = await utils.getArtifactList(
+      dsDir,
+      'datasource',
+      false,
+    );
+    debug(datasourcesList);
+
+    this.dataSourceChoices = datasourcesList.map(s =>
+      modelDiscoverer.loadDataSource(
+        path.resolve(dsDir, `${utils.toFileName(s)}.datasource.js`),
+      ),
+    );
+
+    if (this.options.dataSource) {
+      if (
+        this.dataSourceChoices
+          .map(d => d.name)
+          .includes(this.options.dataSource)
+      ) {
+        Object.assign(this.artifactInfo, {
+          dataSource: this.dataSourceChoices.find(
+            d => d.name === this.options.dataSource,
+          ),
+        });
+      }
+    }
+    debug(`Done importing datasources`);
+  }
+
+  /**
+   * Ask the user to select the data source from which to discover
+   */
+  promptDataSource() {
+    /* istanbul ignore next */
+    if (this.shouldExit()) return;
+    const prompts = [
+      {
+        name: 'dataSource',
+        message: g.f('Select the connector to discover'),
+        type: 'list',
+        choices: this.dataSourceChoices,
+        when:
+          this.artifactInfo.dataSource === undefined &&
+          !this.artifactInfo.modelDefinitions,
+      },
+    ];
+
+    return this.prompt(prompts).then(answer => {
+      /* istanbul ignore next */
+      if (!answer.dataSource) return;
+      debug(`Datasource answer: ${JSON.stringify(answer)}`);
+
+      this.artifactInfo.dataSource = this.dataSourceChoices.find(
+        d => d.name === answer.dataSource,
+      );
+    });
+  }
+
+  /**
+   * Puts all discoverable models in this.modelChoices
+   */
+  async discoverModelInfos() {
+    /* istanbul ignore if */
+    if (this.artifactInfo.modelDefinitions) return;
+    debug(`Getting all models from ${this.artifactInfo.dataSource.name}`);
+
+    this.modelChoices = await modelMaker.discoverModelNames(
+      this.artifactInfo.dataSource,
+      {
+        views: this.options.views,
+        schema: this.options.schema,
+      },
+    );
+    debug(
+      `Got ${this.modelChoices.length} models from ${this.artifactInfo.dataSource.name}`,
+    );
+  }
+
+  /**
+   * Now that we have a list of all models for a datasource,
+   * ask which models to discover
+   */
+  promptModelChoices() {
+    // If we are discovering all we don't need to prompt
+    /* istanbul ignore next */
+    if (this.options.all) {
+      this.discoveringModels = this.modelChoices;
+    }
+
+    const prompts = [
+      {
+        name: 'discoveringModels',
+        message: g.f('Select the models which to discover'),
+        type: 'checkbox',
+        choices: this.modelChoices,
+        when:
+          this.discoveringModels === undefined &&
+          !this.artifactInfo.modelDefinitions,
+        // Require at least one model to be selected
+        // This prevents users from accidentally pressing ENTER instead of SPACE
+        // to select a model from the list
+        validate: result => !!result.length,
+      },
+    ];
+
+    return this.prompt(prompts).then(answers => {
+      /* istanbul ignore next */
+      if (!answers.discoveringModels) return;
+      debug(`Models chosen: ${JSON.stringify(answers)}`);
+      this.discoveringModels = [];
+      answers.discoveringModels.forEach(m => {
+        this.discoveringModels.push(this.modelChoices.find(c => c.name === m));
+      });
+    });
+  }
+
+  /**
+   * Prompts what naming convention they would like to have for column names.
+   */
+  promptColNamingConvention() {
+    this.namingConvention = [
+      {
+        name: g.f('Camel case (exampleColumn) (Recommended)'),
+        value: 'camelCase',
+      },
+      {
+        name: g.f('No conversion (EXAMPLE_COLUMN)'),
+        value: 'noCase',
+      },
+    ];
+    return this.prompt([
+      {
+        name: 'disableCamelCase',
+        message: g.f(
+          'Select a convention to convert db column names(EXAMPLE_COLUMN) to model property names:',
+        ),
+        type: 'list',
+        choices: this.namingConvention,
+        default: false,
+      },
+    ]).then(props => {
+      /* istanbul ignore next */
+      if (!props.disableCamelCase) return;
+      props.disableCamelCase = props.disableCamelCase !== 'camelCase';
+
+      Object.assign(this.artifactInfo, props);
+      /* istanbul ignore next */
+      if (props.disableCamelCase) {
+        this.log(
+          chalk.red(
+            g.f(
+              'By disabling Camel case, you might need to specify these customized names in relation definition.',
+            ),
+          ),
+        );
+      }
+      debug(`props after naming convention prompt: ${props.disableCamelCase}`);
+      return props;
+    });
+  }
+
+  /**
+   * Using artifactInfo.dataSource,
+   * artifactInfo.modelNameOptions
+   *
+   * this will discover every model
+   * and put it in artifactInfo.modelDefinitions
+   * @returns {Promise<void>}
+   */
+  async getAllModelDefs() {
+    /* istanbul ignore next */
+    if (this.shouldExit()) {
+      await this.artifactInfo.dataSource.disconnect();
+      return false;
+    }
+    this.artifactInfo.modelDefinitions = [];
+    // eslint-disable-next-line @typescript-eslint/prefer-for-of
+    for (let i = 0; i < this.discoveringModels.length; i++) {
+      const modelInfo = this.discoveringModels[i];
+      debug(`Discovering: ${modelInfo.name}...`);
+      const modelDefinition = await modelMaker.discoverSingleModel(
+        this.artifactInfo.dataSource,
+        modelInfo.name,
+        {
+          schema: modelInfo.owner,
+          disableCamelCase: this.artifactInfo.disableCamelCase,
+          associations: this.options.relations,
+        },
+      );
+      if (this.options.optionalId) {
+        // Find id properties (can be multiple ids if using composite key)
+        const idProperties = Object.values(modelDefinition.properties).filter(
+          property => property.id,
+        );
+        // Mark as not required
+        idProperties.forEach(property => {
+          property.required = false;
+        });
+      }
+      this.artifactInfo.modelDefinitions.push(modelDefinition);
+      debug(`Discovered: ${modelInfo.name}`);
+    }
+  }
+
+  /**
+   * Iterate through all the models we have discovered and scaffold
+   */
+  async scaffold() {
+    // Exit if needed
+    /* istanbul ignore next */
+    if (this.shouldExit()) {
+      await this.artifactInfo.dataSource.disconnect();
+      return;
+    }
+    this.artifactInfo.indexesToBeUpdated =
+      this.artifactInfo.indexesToBeUpdated || [];
+
+    // eslint-disable-next-line @typescript-eslint/prefer-for-of
+    for (let i = 0; i < this.artifactInfo.modelDefinitions.length; i++) {
+      const modelDefinition = this.artifactInfo.modelDefinitions[i];
+      const templateData = importDiscoveredModel(modelDefinition);
+
+      debug(
+        'Generating model %s from template data',
+        modelDefinition.name,
+        templateData,
+      );
+
+      const fullPath = path.resolve(
+        this.options.outDir || this.artifactInfo.outDir,
+        utils.getModelFileName(modelDefinition.name),
+      );
+      debug(`Writing: ${fullPath}`);
+
+      if (this.options.relations) {
+        const relationImports = [];
+        const relationDestinationImports = [];
+        const foreignKeys = {};
+        for (const relationName in templateData.settings.relations) {
+          const relation = templateData.settings.relations[relationName];
+          const targetModel = this.artifactInfo.modelDefinitions.find(
+            model => model.name === relation.model,
+          );
+          // If targetModel is not in discovered models, skip creating relation
+          if (targetModel) {
+            Object.assign(templateData.properties[relation.foreignKey], {
+              relation,
+            });
+            relationImports.push(relation.type);
+            relationDestinationImports.push(relation.model);
+
+            foreignKeys[relationName] = {};
+            Object.assign(foreignKeys[relationName], {
+              name: relationName,
+              entity: relation.model,
+              entityKey: Object.entries(targetModel.properties).find(
+                x => x?.[1].id === 1,
+              )?.[0],
+              foreignKey: relation.foreignKey,
+            });
+          }
+        }
+        templateData.relationImports = relationImports;
+        templateData.relationDestinationImports = relationDestinationImports;
+        // Delete relation from modelSettings
+        delete templateData.settings.relations;
+        if (Object.keys(foreignKeys)?.length > 0) {
+          Object.assign(templateData.settings, {foreignKeys});
+        }
+        templateData.modelSettings = utils.stringifyModelSettings(
+          templateData.settings,
+        );
+      }
+
+      this.copyTemplatedFiles(
+        modelDiscoverer.MODEL_TEMPLATE_PATH,
+        fullPath,
+        templateData,
+      );
+
+      this.artifactInfo.indexesToBeUpdated.push({
+        dir: this.options.outDir || this.artifactInfo.outDir,
+        file: utils.getModelFileName(modelDefinition.name),
+      });
+
+      await this.artifactInfo.dataSource.disconnect();
+    }
+
+    // This part at the end is just for the ArtifactGenerator
+    // end message to output something nice, before it was "Discover undefined was created in src/models/"
+    this.artifactInfo.type = 'Models';
+    this.artifactInfo.name = this.artifactInfo.modelDefinitions
+      .map(d => d.name)
+      .join(',');
+  }
+
+  async end() {
+    await super.end();
+  }
+};

package/generators/example/downloader.js

@@ -0,0 +1,16 @@
+// Copyright IBM Corp. and LoopBack contributors 2018. 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 pacote = require('pacote');
+
+module.exports = async function downloadAndExtractExample(exampleName, cwd) {
+  const packageSpec = `@loopback/example-${exampleName}`;
+  const outDir = path.join(cwd, `loopback4-example-${exampleName}`);
+  await pacote.extract(packageSpec, outDir);
+  return outDir;
+};

package/generators/example/index.js

@@ -0,0 +1,176 @@
+// 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
+
+'use strict';
+
+const BaseGenerator = require('../../lib/base-generator');
+const chalk = require('chalk');
+const downloadAndExtractExample = require('./downloader');
+const path = require('path');
+const fs = require('fs-extra');
+const g = require('../../lib/globalize');
+
+const EXAMPLES = {
+  todo: g.f('Tutorial example on how to build an application with LoopBack 4.'),
+  'todo-list': g.f(
+    'Continuation of the todo example using relations in LoopBack 4.',
+  ),
+  'hello-world': g.f('A simple hello-world application using LoopBack 4.'),
+  'log-extension': g.f('An example extension project for LoopBack 4.'),
+  'rpc-server': g.f('A basic RPC server using a made-up protocol.'),
+  'soap-calculator': g.f('An example on how to integrate SOAP web services.'),
+  'express-composition': g.f(
+    'A simple Express application that uses LoopBack 4 REST API.',
+  ),
+  context: g.f('Standalone examples showing how to use @loopback/context.'),
+  'greeter-extension': g.f(
+    'An example showing how to implement the extension point/extension pattern.',
+  ),
+  'greeting-app': g.f(
+    'An example showing how to compose an application from component and ' +
+      'controllers, interceptors, and observers.',
+  ),
+  'lb3-application': g.f(
+    'An example LoopBack 3 application mounted in a LoopBack 4 project.',
+  ),
+  'rest-crud': g.f(
+    'A simplified version of the Todo example that only requires a model and ' +
+      'a datasource.',
+  ),
+  'file-transfer': g.f(
+    'An example showing how to expose APIs to upload/download files.',
+  ),
+  'access-control-migration': g.f(
+    'An access control example migrated from the LoopBack 3 repository ' +
+      'loopback-example-access-control.',
+  ),
+  'metrics-prometheus': g.f(
+    'An example illustrating metrics using Prometheus.',
+  ),
+  'validation-app': g.f('An example demonstrating how to add validations.'),
+  'multi-tenancy': g.f(
+    'An example application to demonstrate how to implement multi-tenancy with LoopBack 4.',
+  ),
+  'passport-login': g.f(
+    'An example implmenting authentication in a LoopBack application using Passport modules.',
+  ),
+  'todo-jwt': g.f('A modified Todo application with JWT authentication.'),
+  webpack: g.f('An example to bundle @loopback/core using webpack.'),
+  graphql: g.f('An example to demonstrate GraphQL integration.'),
+  socketio: g.f('A basic implementation of Socket.IO'),
+};
+Object.freeze(EXAMPLES);
+
+module.exports = class extends BaseGenerator {
+  static getAllExamples() {
+    return EXAMPLES;
+  }
+
+  // Note: arguments and options should be defined in the constructor.
+  constructor(args, opts) {
+    super(args, opts);
+  }
+
+  _setupGenerator() {
+    this.projectType = 'example';
+    this.argument('example-name', {
+      type: String,
+      description: g.f('Name of the example to clone'),
+      required: false,
+    });
+
+    return super._setupGenerator();
+  }
+
+  setOptions() {
+    return super.setOptions();
+  }
+
+  help() {
+    const examplesHelp = Object.keys(EXAMPLES)
+      .map(name => `  ${name}: ${EXAMPLES[name]}`)
+      .join('\n');
+
+    return super.help() + `\nAvailable examples:\n${examplesHelp}\n`;
+  }
+
+  _describeExamples() {}
+
+  promptExampleName() {
+    if (this.shouldExit()) return;
+    if (this.options['example-name']) {
+      this.exampleName = this.options['example-name'];
+      return;
+    }
+
+    const choices = Object.keys(EXAMPLES).map(k => {
+      return {
+        name: `${k}: ${EXAMPLES[k]}`,
+        value: `${k}`,
+        short: `${k}`,
+      };
+    });
+    const prompts = [
+      {
+        name: 'name',
+        message: g.f('What example would you like to clone?'),
+        type: 'list',
+        choices,
+      },
+    ];
+    return this.prompt(prompts).then(
+      answers => (this.exampleName = answers.name),
+    );
+  }
+
+  validateExampleName() {
+    if (this.shouldExit()) return;
+    if (this.exampleName in EXAMPLES) return;
+    this.exit(
+      g.f(
+        'Invalid example name: %s\n' +
+          'Run "lb4 example --help" to print the list of available example names.',
+        this.exampleName,
+      ),
+    );
+  }
+
+  async downloadAndExtract() {
+    if (this.shouldExit()) return false;
+    const cwd = process.cwd();
+    const absOutDir = await downloadAndExtractExample(this.exampleName, cwd);
+    this.outDir = path.relative(cwd, absOutDir);
+    const tsconfig = path.join(absOutDir, 'tsconfig.json');
+
+    // Support older versions of examples that are using `tsconfig.build.json`
+    const tsBuildConfig = path.join(absOutDir, 'tsconfig.build.json');
+    const exists = await fs.pathExists(tsconfig);
+    if (!exists) {
+      return fs.rename(tsBuildConfig, tsconfig);
+    }
+
+    // Recent versions of examples are using project references inside monorepo,
+    // see https://github.com/loopbackio/loopback-next/pull/5155
+    // We must switch to standalone mode (no project references) when the code
+    // was checked out outside of our monorepo.
+    const tsconfigContent = await fs.readJson(tsconfig);
+    delete tsconfigContent.references;
+    tsconfigContent.compilerOptions.composite = false;
+    await fs.writeJson(tsconfig, tsconfigContent);
+  }
+
+  install() {
+    if (this.shouldExit()) return false;
+    this.destinationRoot(this.outDir);
+    return super.install();
+  }
+
+  async end() {
+    await super.end();
+    this.log();
+    this.log(g.f('The example was cloned to %s.', chalk.green(this.outDir)));
+    this.log();
+  }
+};