@loopback/cli 4.0.0-alpha.7 → 4.0.0

package/generators/app/templates/src/__tests__/acceptance/test-helper.ts.ejs

@@ -0,0 +1,32 @@
+import {<%= project.applicationName %>} from '../..';
+import {
+  createRestAppClient,
+  givenHttpServerConfig,
+  Client,
+} from '@loopback/testlab';
+
+export async function setupApplication(): Promise<AppWithClient> {
+  const restConfig = givenHttpServerConfig({
+    // Customize the server configuration here.
+    // Empty values (undefined, '') will be ignored by the helper.
+    //
+    // host: process.env.HOST,
+    // port: +process.env.PORT,
+  });
+
+  const app = new <%= project.applicationName %>({
+    rest: restConfig,
+  });
+
+  await app.boot();
+  await app.start();
+
+  const client = createRestAppClient(app);
+
+  return {app, client};
+}
+
+export interface AppWithClient {
+  app: <%= project.applicationName %>;
+  client: Client;
+}

package/generators/app/templates/src/application.ts.ejs

@@ -0,0 +1,70 @@
+import {BootMixin} from '@loopback/boot';
+import {ApplicationConfig} from '@loopback/core';
+import {
+  RestExplorerBindings,
+  RestExplorerComponent,
+} from '@loopback/rest-explorer';
+<% if (project.repositories) { -%>
+import {RepositoryMixin} from '@loopback/repository';
+<% } -%>
+import {RestApplication} from '@loopback/rest';
+<% if (project.services) { -%>
+import {ServiceMixin} from '@loopback/service-proxy';
+<% } -%>
+<% if (project.apiconnect) { -%>
+import {
+  ApiConnectBindings,
+  ApiConnectComponent,
+  ApiConnectSpecOptions,
+} from '@loopback/apiconnect';
+<% } -%>
+import path from 'path';
+import {MySequence} from './sequence';
+
+export {ApplicationConfig};
+
+<% if (project.appClassWithMixins) { -%>
+export class <%= project.applicationName %> extends BootMixin(
+  <%= project.appClassWithMixins %>,
+) {
+<%
+} else { // no optional mixins
+-%>
+export class <%= project.applicationName %> extends BootMixin(RestApplication) {
+<% } -%>
+  constructor(options: ApplicationConfig = {}) {
+    super(options);
+
+    // Set up the custom sequence
+    this.sequence(MySequence);
+
+    // Set up default home page
+    this.static('/', path.join(__dirname, '../public'));
+
+    // Customize @loopback/rest-explorer configuration here
+    this.configure(RestExplorerBindings.COMPONENT).to({
+      path: '/explorer',
+    });
+    this.component(RestExplorerComponent);
+<%_ if (project.apiconnect) { -%>
+    this.component(ApiConnectComponent);
+    const apiConnectOptions: ApiConnectSpecOptions = {
+      targetUrl: 'http://localhost:3000/',
+    };
+    this.configure(ApiConnectBindings.API_CONNECT_SPEC_ENHANCER).to(
+      apiConnectOptions,
+    );
+<%_ } -%>
+
+    this.projectRoot = __dirname;
+    // Customize @loopback/boot Booter Conventions here
+    this.bootOptions = {
+      controllers: {
+        // Customize ControllerBooter Conventions here
+        dirs: ['controllers'],
+        extensions: ['.controller.js'],
+        nested: true,
+      },
+    };
+  }
+}

package/generators/app/templates/src/controllers/README.md

@@ -1,3 +1,9 @@
 # Controllers
 
 This directory contains source files for the controllers exported by this app.
+
+To add a new empty controller, type in `lb4 controller [<name>]` from the
+command-line of your application's root directory.
+
+For more information, please visit
+[Controller generator](http://loopback.io/doc/en/lb4/Controller-generator.html).

package/generators/app/templates/src/controllers/index.ts.ejs

@@ -0,0 +1 @@
+export * from './ping.controller';

package/generators/app/templates/src/controllers/ping.controller.ts.ejs

@@ -0,0 +1,55 @@
+import {inject} from '@loopback/core';
+import {
+  Request,
+  RestBindings,
+  get,
+  response,
+  ResponseObject,
+} from '@loopback/rest';
+
+/**
+ * OpenAPI response for ping()
+ */
+const PING_RESPONSE: ResponseObject = {
+  description: 'Ping Response',
+  content: {
+    'application/json': {
+      schema: {
+        type: 'object',
+        title: 'PingResponse',
+        properties: {
+          greeting: {type: 'string'},
+          date: {type: 'string'},
+          url: {type: 'string'},
+          headers: {
+            type: 'object',
+            properties: {
+              'Content-Type': {type: 'string'},
+            },
+            additionalProperties: true,
+          },
+        },
+      },
+    },
+  },
+};
+
+/**
+ * A simple controller to bounce back http requests
+ */
+export class PingController {
+  constructor(@inject(RestBindings.Http.REQUEST) private req: Request) {}
+
+  // Map to `GET /ping`
+  @get('/ping')
+  @response(200, PING_RESPONSE)
+  ping(): object {
+    // Reply with a greeting, the current time, the url, and request headers
+    return {
+      greeting: 'Hello from LoopBack',
+      date: new Date(),
+      url: this.req.url,
+      headers: Object.assign({}, this.req.headers),
+    };
+  }
+}

package/generators/app/templates/src/datasources/README.md

@@ -0,0 +1,3 @@
+# Datasources
+
+This directory contains config for datasources used by this app.

package/generators/app/templates/src/index.ts.ejs

@@ -0,0 +1,39 @@
+import {ApplicationConfig, <%= project.applicationName %>} from './application';
+
+export * from './application';
+
+export async function main(options: ApplicationConfig = {}) {
+  const app = new <%= project.applicationName %>(options);
+  await app.boot();
+  await app.start();
+
+  const url = app.restServer.url;
+  console.log(`Server is running at ${url}`);
+  console.log(`Try ${url}/ping`);
+
+  return app;
+}
+
+if (require.main === module) {
+  // Run the application
+  const config = {
+    rest: {
+      port: +(process.env.PORT ?? 3000),
+      host: process.env.HOST,
+      // The `gracePeriodForClose` provides a graceful close for http/https
+      // servers with keep-alive clients. The default value is `Infinity`
+      // (don't force-close). If you want to immediately destroy all sockets
+      // upon stop, set its value to `0`.
+      // See https://www.npmjs.com/package/stoppable
+      gracePeriodForClose: 5000, // 5 seconds
+      openApiSpec: {
+        // useful when used with OpenAPI-to-GraphQL to locate your application
+        setServersFromRequest: true,
+      },
+    },
+  };
+  main(config).catch(err => {
+    console.error('Cannot start the application.', err);
+    process.exit(1);
+  });
+}

package/generators/app/templates/src/migrate.ts.ejs

@@ -0,0 +1,20 @@
+import {<%= project.applicationName %>} from './application';
+
+export async function migrate(args: string[]) {
+  const existingSchema = args.includes('--rebuild') ? 'drop' : 'alter';
+  console.log('Migrating schemas (%s existing schema)', existingSchema);
+
+  const app = new <%= project.applicationName %>();
+  await app.boot();
+  await app.migrateSchema({existingSchema});
+
+  // Connectors usually keep a pool of opened connections,
+  // this keeps the process running even after all work is done.
+  // We need to exit explicitly.
+  process.exit(0);
+}
+
+migrate(process.argv).catch(err => {
+  console.error('Cannot migrate database schema', err);
+  process.exit(1);
+});

package/generators/app/templates/src/models/README.md

@@ -0,0 +1,3 @@
+# Models
+
+This directory contains code for models provided by this app.

package/generators/app/templates/src/openapi-spec.ts.ejs

@@ -0,0 +1,23 @@
+import {ApplicationConfig} from '@loopback/core';
+import {<%= project.applicationName %>} from './application';
+
+/**
+ * Export the OpenAPI spec from the application
+ */
+async function exportOpenApiSpec(): Promise<void> {
+  const config: ApplicationConfig = {
+    rest: {
+      port: +(process.env.PORT ?? 3000),
+      host: process.env.HOST ?? 'localhost',
+    },
+  };
+  const outFile = process.argv[2] ?? '';
+  const app = new <%= project.applicationName %>(config);
+  await app.boot();
+  await app.exportOpenApiSpec(outFile);
+}
+
+exportOpenApiSpec().catch(err => {
+  console.error('Fail to export OpenAPI spec from the application.', err);
+  process.exit(1);
+});

package/generators/app/templates/src/sequence.ts.ejs

@@ -0,0 +1,3 @@
+import {MiddlewareSequence} from '@loopback/rest';
+
+export class MySequence extends MiddlewareSequence {}

package/generators/controller/index.js

@@ -0,0 +1,279 @@
+// 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
+
+// no translation: Controller
+'use strict';
+const _ = require('lodash');
+const ArtifactGenerator = require('../../lib/artifact-generator');
+const debug = require('../../lib/debug')('controller-generator');
+const inspect = require('util').inspect;
+const path = require('path');
+const chalk = require('chalk');
+const utils = require('../../lib/utils');
+const g = require('../../lib/globalize');
+
+// Exportable constants
+module.exports = class ControllerGenerator extends ArtifactGenerator {
+  // Note: arguments and options should be defined in the constructor.
+  constructor(args, opts) {
+    super(args, opts);
+  }
+
+  static get BASIC() {
+    return g.f('Empty Controller');
+  }
+
+  static get REST() {
+    return g.f('REST Controller with CRUD functions');
+  }
+
+  _setupGenerator() {
+    this.artifactInfo = {
+      type: 'controller',
+      rootDir: 'src',
+    };
+
+    // XXX(kjdelisle): These should be more extensible to allow custom paths
+    // for each artifact type.
+
+    this.artifactInfo.outDir = path.resolve(
+      this.artifactInfo.rootDir,
+      'controllers',
+    );
+    this.artifactInfo.modelDir = path.resolve(
+      this.artifactInfo.rootDir,
+      'models',
+    );
+    this.artifactInfo.repositoryDir = path.resolve(
+      this.artifactInfo.rootDir,
+      'repositories',
+    );
+
+    this.option('controllerType', {
+      type: String,
+      required: false,
+      description: g.f('Type for the %s', this.artifactInfo.type),
+    });
+
+    return super._setupGenerator();
+  }
+
+  setOptions() {
+    return super.setOptions();
+  }
+
+  checkLoopBackProject() {
+    if (this.shouldExit()) return;
+    return super.checkLoopBackProject();
+  }
+
+  promptArtifactName() {
+    if (this.shouldExit()) return;
+    return super.promptArtifactName();
+  }
+
+  promptArtifactType() {
+    debug('Prompting for controller type');
+    if (this.shouldExit()) return;
+
+    super.promptWarningMsgForName();
+    // inform user what controller/file names will be created
+    super.promptClassFileName(
+      'controller',
+      'controllers',
+      utils.toClassName(this.artifactInfo.name),
+    );
+
+    if (this.options.controllerType) {
+      Object.assign(this.artifactInfo, {
+        controllerType: this.options.controllerType,
+      });
+      return;
+    }
+
+    return this.prompt([
+      {
+        type: 'list',
+        name: 'controllerType',
+        message: g.f('What kind of controller would you like to generate?'),
+        when: this.artifactInfo.controllerType === undefined,
+        choices: [ControllerGenerator.BASIC, ControllerGenerator.REST],
+        default: ControllerGenerator.BASIC,
+      },
+    ])
+      .then(props => {
+        Object.assign(this.artifactInfo, props);
+        return props;
+      })
+      .catch(err => {
+        debug(`Error during controller type prompt: ${err.stack}`);
+        return this.exit(err);
+      });
+  }
+
+  async promptArtifactCrudVars() {
+    if (this.shouldExit()) return;
+    if (
+      !this.artifactInfo.controllerType ||
+      this.artifactInfo.controllerType === ControllerGenerator.BASIC
+    ) {
+      return;
+    }
+
+    let modelList, repositoryList;
+
+    try {
+      modelList = await utils.getArtifactList(
+        this.artifactInfo.modelDir,
+        'model',
+      );
+
+      repositoryList = await utils.getArtifactList(
+        this.artifactInfo.repositoryDir,
+        'repository',
+        true,
+      );
+    } catch (err) {
+      return this.exit(err);
+    }
+
+    if (_.isEmpty(modelList)) {
+      const file = g.f('No models found in %s. ', this.artifactInfo.modelDir);
+      const site = g.f(
+        'Please visit http://loopback.io/doc/en/lb4/Controller-generator.html for information on how models are discovered.',
+      );
+      return this.exit(file + chalk.yellow(site));
+    }
+    if (_.isEmpty(repositoryList)) {
+      const file = g.f(
+        'No repositories found in %s. ',
+        this.artifactInfo.repositoryDir,
+      );
+      const site = g.f(
+        'Please visit http://loopback.io/doc/en/lb4/Controller-generator.html for information on how repositories are discovered.',
+      );
+      return this.exit(file + chalk.yellow(site));
+    }
+    return this.prompt([
+      {
+        type: 'list',
+        name: 'modelName',
+        message: g.f(
+          'What is the name of the model to use with this CRUD repository?',
+        ),
+        choices: modelList,
+        when: this.artifactInfo.modelName === undefined,
+        default: modelList[0],
+        validate: utils.validateClassName,
+      },
+      {
+        type: 'list',
+        name: 'repositoryName',
+        message: g.f('What is the name of your CRUD repository?'),
+        choices: repositoryList,
+        when: this.artifactInfo.repositoryName === undefined,
+        default: repositoryList[0],
+        validate: utils.validateClassName,
+      },
+      {
+        type: 'input',
+        name: 'id',
+        message: g.f('What is the name of ID property?'),
+        when: this.artifactInfo.id === undefined,
+        default: 'id',
+      },
+      {
+        type: 'list',
+        name: 'idType',
+        message: g.f('What is the type of your ID?'),
+        choices: ['number', 'string', 'object'],
+        when: this.artifactInfo.idType === undefined,
+        default: 'number',
+      },
+      {
+        type: 'confirm',
+        name: 'idOmitted',
+        message: g.f('Is the id omitted when creating a new instance?'),
+        default: true,
+      },
+      {
+        type: 'input',
+        name: 'httpPathName',
+        message: g.f('What is the base HTTP path name of the CRUD operations?'),
+        when: this.artifactInfo.httpPathName === undefined,
+        default: answers =>
+          utils.prependBackslash(
+            utils.pluralize(utils.urlSlug(answers.modelName)),
+          ),
+        validate: utils.validateUrlSlug,
+        filter: utils.prependBackslash,
+      },
+    ])
+      .then(props => {
+        debug(`props: ${inspect(props)}`);
+        Object.assign(this.artifactInfo, props);
+        // Ensure that the artifact names are valid.
+        [
+          this.artifactInfo.name,
+          this.artifactInfo.modelName,
+          this.artifactInfo.repositoryName,
+        ].forEach(item => {
+          item = utils.toClassName(item);
+        });
+        // Create camel-case names for variables.
+        this.artifactInfo.repositoryNameCamel = utils.camelCase(
+          this.artifactInfo.repositoryName,
+        );
+        return props;
+      })
+      .catch(err => {
+        debug(`Error during prompt for controller variables: ${err}`);
+        return this.exit(err);
+      });
+  }
+
+  scaffold() {
+    // We don't want to call the base scaffold function since it copies
+    // all of the templates!
+    if (this.shouldExit()) return false;
+    this.artifactInfo.className = utils.toClassName(this.artifactInfo.name);
+    this.artifactInfo.outFile =
+      utils.toFileName(this.artifactInfo.name) + '.controller.ts';
+    if (debug.enabled) {
+      debug(`Artifact output filename set to: ${this.artifactInfo.outFile}`);
+    }
+    this.artifactInfo.modelVariableName = utils.toVarName(
+      this.artifactInfo.modelName || '',
+    );
+
+    // renames the file
+    let template = 'controller-template.ts.ejs';
+    switch (this.artifactInfo.controllerType) {
+      case ControllerGenerator.REST:
+        template = 'controller-rest-template.ts.ejs';
+        break;
+      default:
+        break;
+    }
+    const source = this.templatePath(path.join('src', 'controllers', template));
+    if (debug.enabled) {
+      debug(`Using template at: ${source}`);
+    }
+    const dest = this.destinationPath(
+      path.join(this.artifactInfo.outDir, this.artifactInfo.outFile),
+    );
+
+    if (debug.enabled) {
+      debug(`artifactInfo: ${inspect(this.artifactInfo)}`);
+      debug(`Copying artifact to: ${dest}`);
+    }
+    this.copyTemplatedFiles(source, dest, this.artifactInfo);
+    return;
+  }
+
+  async end() {
+    await super.end();
+  }
+};