strapi/packages/strapi-generate-new/lib/before.js

'use strict';

/**
 * Module dependencies
 */

// Node.js core.
const path = require('path');
const os = require('os');
const crypto = require('crypto');

// Public node modules.
const _ = require('lodash');
const { cyan, green } = require('chalk');
const fs = require('fs-extra');
const inquirer = require('inquirer');
const execa = require('execa');
const uuid = require('uuid/v4');
const rimraf = require('rimraf');

// Logger.
const { packageManager } = require('strapi-utils');
const trackSuccess = require('./success');

/**
 * This `before` function is run before generating targets.
 * Validate, configure defaults, get extra dependencies, etc.
 *
 * @param {Object} scope
 * @param {Function} cb
 */

/* eslint-disable no-useless-escape */
module.exports = (scope, cb) => {
  // App info.
  const hasDatabaseConfig = !!scope.database;

  _.defaults(scope, {
    name:
      scope.name === '.' || !scope.name
        ? scope.name
        : path.basename(process.cwd()),
    author: process.env.USER || 'A Strapi developer',
    email: process.env.EMAIL || '',
    year: new Date().getFullYear(),
    license: 'MIT',
    database: {},
    additionalsDependencies: [
      'strapi-plugin-settings-manager',
      'strapi-plugin-content-type-builder',
      'strapi-plugin-content-manager',
      'strapi-plugin-users-permissions',
      'strapi-plugin-email',
      'strapi-plugin-upload',
    ],
  });

  // Make changes to the rootPath where the Strapi project will be created.
  scope.rootPath = path.resolve(process.cwd(), scope.name || '');
  scope.tmpPath = path.resolve(
    os.tmpdir(),
    `strapi${crypto.randomBytes(6).toString('hex')}`
  );
  scope.uuid = uuid();

  trackSuccess('willCreateProject', scope);

  // Ensure we aren't going to inadvertently delete any files.
  try {
    const files = fs.readdirSync(scope.rootPath);
    if (files.length > 1) {
      return console.log(
        `⛔️ ${cyan('strapi new')} can only be called in an empty directory.`
      );
    }
  } catch (err) {
    // ...
  }

  if (hasDatabaseConfig) {
    console.log(
      `Database determined by CLI args: ${scope.database.settings.client}`
    );
  }

  const connectionValidation = async () => {
    const databaseChoices = [
      {
        name: 'SQLite',
        value: {
          database: 'sqlite',
          connector: 'strapi-hook-bookshelf',
          module: 'sqlite3',
        },
      },
      {
        name: 'MongoDB',
        value: {
          database: 'mongo',
          connector: 'strapi-hook-mongoose',
        },
      },
      {
        name: 'MySQL',
        value: {
          database: 'mysql',
          connector: 'strapi-hook-bookshelf',
          module: 'mysql',
        },
      },
      {
        name: 'Postgres',
        value: {
          database: 'postgres',
          connector: 'strapi-hook-bookshelf',
          module: 'pg',
        },
      },
    ];

    const answers = await inquirer.prompt([
      {
        when: !scope.quick && !hasDatabaseConfig,
        type: 'list',
        name: 'type',
        message: 'Choose your installation type',
        choices: [
          {
            name: 'Quickstart (recommended)',
            value: 'quick',
          },
          {
            name: 'Custom (manual settings)',
            value: 'custom',
          },
        ],
      },
      {
        when: answers => {
          return !hasDatabaseConfig && answers.type === 'custom';
        },
        type: 'list',
        name: 'client',
        message: 'Choose your main database:',
        choices: databaseChoices,
        default: () => {
          if (scope.client) {
            return _.findIndex(databaseChoices, {
              value: _.omit(scope.client, ['version']),
            });
          }
        },
      },
    ]);

    scope.quick = answers.type === 'quick' || scope.quick;
    const isQuick = scope.quick;

    if (isQuick) {
      answers.client = databaseChoices[0].value;
    }

    if (hasDatabaseConfig) {
      const databaseChoice = _.find(databaseChoices, [
        'value.database',
        scope.database.settings.client,
      ]);
      scope.database.connector = databaseChoice.value.connector;
      answers.client = {
        ...databaseChoice.value,
      };
    } else {
      _.assign(scope.database, {
        connector: answers.client.connector,
        settings: {
          client: answers.client.database,
        },
        options: {},
      });
    }

    scope.client = answers.client;

    const asyncFn = [
      new Promise(async resolve => {
        const isMongo = scope.client.database === 'mongo';
        const isSQLite = scope.database.settings.client === 'sqlite';

        let answers = await inquirer.prompt([
          {
            when: !hasDatabaseConfig && !isSQLite,
            type: 'input',
            name: 'database',
            message: 'Database name:',
            default: _.get(scope.database, 'database', scope.name),
          },
          {
            when: !hasDatabaseConfig && !isSQLite,
            type: 'input',
            name: 'host',
            message: 'Host:',
            default: _.get(scope.database, 'host', '127.0.0.1'),
          },
          {
            when: !hasDatabaseConfig && isMongo,
            type: 'boolean',
            name: 'srv',
            message: '+srv connection:',
            default: _.get(scope.database, 'srv', false),
          },
          {
            when: !hasDatabaseConfig && !isSQLite,
            type: 'input',
            name: 'port',
            message: `Port${
              isMongo ? ' (It will be ignored if you enable +srv)' : ''
            }:`,
            default: answers => {
              // eslint-disable-line no-unused-vars
              if (_.get(scope.database, 'port')) {
                return scope.database.port;
              }

              const ports = {
                mongo: 27017,
                postgres: 5432,
                mysql: 3306,
              };

              return ports[scope.client.database];
            },
          },
          {
            when: !hasDatabaseConfig && !isSQLite,
            type: 'input',
            name: 'username',
            message: 'Username:',
            default: _.get(scope.database, 'username', undefined),
          },
          {
            when: !hasDatabaseConfig && !isSQLite,
            type: 'password',
            name: 'password',
            message: 'Password:',
            mask: '*',
            default: _.get(scope.database, 'password', undefined),
          },
          {
            when: !hasDatabaseConfig && isMongo,
            type: 'input',
            name: 'authenticationDatabase',
            message: 'Authentication database (Maybe "admin" or blank):',
            default: _.get(scope.database, 'authenticationDatabase', undefined),
          },
          {
            when: !hasDatabaseConfig && !isSQLite,
            type: 'boolean',
            name: 'ssl',
            message: 'Enable SSL connection:',
            default: _.get(scope.database, 'ssl', false),
          },
          {
            when: !hasDatabaseConfig && isSQLite && !isQuick,
            type: 'input',
            name: 'filename',
            message: 'Filename:',
            default: () => '.tmp/data.db',
          },
        ]);

        if (isQuick) {
          answers.filename = '.tmp/data.db';
        }

        if (hasDatabaseConfig) {
          answers = _.merge(
            _.omit(scope.database.settings, ['client']),
            scope.database.options
          );
        }

        scope.database.settings.host = answers.host;
        scope.database.settings.port = answers.port;
        scope.database.settings.database = answers.database;
        scope.database.settings.username = answers.username;
        scope.database.settings.password = answers.password;

        if (answers.filename) {
          scope.database.settings.filename = answers.filename;
        }
        if (answers.srv) {
          scope.database.settings.srv = _.toString(answers.srv) === 'true';
        }
        if (answers.authenticationDatabase) {
          scope.database.options.authenticationDatabase =
            answers.authenticationDatabase;
        }

        // SQLite requirements.
        if (isSQLite) {
          // Necessary for SQLite configuration (https://knexjs.org/#Builder-insert).
          scope.database.options = {
            useNullAsDefault: true,
          };
        }

        if (answers.ssl && scope.client.database === 'mongo') {
          scope.database.options.ssl = _.toString(answers.ssl) === 'true';
        } else if (answers.ssl) {
          scope.database.settings.ssl = _.toString(answers.ssl) === 'true';
        }

        console.log();
        if (isQuick) {
          console.log('✅ Connected to the database');
        } else {
          console.log(
            '⏳ Testing database connection...\r\nIt might take a minute, please have a coffee ☕️'
          );
        }

        resolve();
      }),
      new Promise(resolve => {
        const isStrapiInstalledWithNPM = packageManager.isStrapiInstalledWithNPM();
        let packageCmd = packageManager.commands(
          'install --prefix',
          scope.tmpPath
        );
        // Manually create the temp directory for yarn
        if (!isStrapiInstalledWithNPM) {
          fs.ensureDirSync(scope.tmpPath);
        }

        let cmd = `${packageCmd} ${scope.client.connector}@${
          scope.strapiPackageJSON.version
        }`;

        if (scope.client.module) {
          cmd += ` ${scope.client.module}`;
        }

        if (scope.client.connector === 'strapi-hook-bookshelf') {
          cmd += ` strapi-hook-knex@${scope.strapiPackageJSON.version}`;
          scope.additionalsDependencies = scope.additionalsDependencies.concat([
            'strapi-hook-knex',
            'knex',
          ]);
        }

        if (isQuick) {
          scope.client.version = 'latest';
          return resolve();
        }

        execa.shell(cmd).then(() => {
          if (scope.client.module) {
            const lock = require(path.join(
              `${scope.tmpPath}`,
              '/node_modules/',
              `${scope.client.module}/package.json`
            ));
            scope.client.version = lock.version;
          }
          resolve();
        });
      }),
    ];

    const connectedToTheDatabase = (withMessage = true) => {
      if (withMessage) {
        console.log();
        console.log(
          `The app has been connected to the database ${green('successfully')}!`
        );
      }

      if (isQuick) {
        trackSuccess('didChooseQuickstart', scope);
      } else {
        trackSuccess('didChooseCustomDatabase', scope);
      }

      trackSuccess('didConnectDatabase', scope);

      cb.success();
    };

    Promise.all(asyncFn).then(() => {
      // Bypass real connection test.
      if (isQuick) {
        return connectedToTheDatabase(false);
      }

      try {
        const connectivityFile = path.join(
          scope.tmpPath,
          'node_modules',
          scope.client.connector,
          'lib',
          'utils',
          'connectivity.js'
        );

        require(connectivityFile)(
          scope,
          connectedToTheDatabase,
          connectionValidation
        );
      } catch (err) {
        trackSuccess('didNotConnectDatabase', scope, err);
        console.log(err);
        rimraf.sync(scope.tmpPath);
        cb.error();
      }
    });
  };

  connectionValidation();
};