267 use async await

jhipster-uml.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node --max-old-space-size=2048
 
 /* eslint-disable global-require */
 const chalk = require('chalk');

lib/editors/editor_detector.js

@@ -33,7 +33,7 @@ module.exports = {
  * @param root {Object} the document's root.
  * @return {string} the editor's name.
  */
-function detect(root) {
+async function detect(root) {
   if (!root) {
     throw new BuildException(
       exceptions.NullPointer, 'The root element can not be null.');
@@ -53,16 +53,16 @@ function detect(root) {
       'Your editor has not been detected, and this should not be happening.'
       + '\nPlease report this issue by mentioning what your editor is.');
   }
-  return askForEditor();
+  return await askForEditor();
 }
 
-function askForEditor() {
+async function askForEditor() {
   const choices = UndetectedEditors;
   choices.push({
     value: 'ERROR',
     name: 'I don\'t see my editor.'
   });
-  const choice = selectMultipleChoices({
+  const choice = await selectMultipleChoices({
     choices,
     question: 'Please choose between the available editors:'
   });

lib/editors/parser_factory.js

@@ -36,7 +36,7 @@ module.exports = {
  * @param args {Object} the arguments: file, files, databaseType, and the noUserManagement flag.
  * @return {Parser} the created parser.
  */
-function createParser(args) {
+async function createParser(args) {
   if (!args || !args.file || !args.databaseType) {
     throw new BuildException(
       exceptions.IllegalArgument,
@@ -47,16 +47,16 @@ function createParser(args) {
     const root = getRootElement(readFileContent(args.file));
     return getFileParserByEditor(args.editor, root, types, args.noUserManagement);
   }
-  return getParserForSingleFile(args.file, types, args.noUserManagement);
+  return await getParserForSingleFile(args.file, types, args.noUserManagement);
 }
 
-function getParserForSingleFile(file, types, noUserManagement) {
-  return getXMIFileParser(file, types, noUserManagement);
+async function getParserForSingleFile(file, types, noUserManagement) {
+  return await getXMIFileParser(file, types, noUserManagement);
 }
 
-function getXMIFileParser(file, databaseType, noUserManagement) {
+async function getXMIFileParser(file, databaseType, noUserManagement) {
   const root = getRootElement(readFileContent(file));
-  const detectedEditor = EditorDetector.detect(root);
+  const detectedEditor = await EditorDetector.detect(root);
   return getFileParserByEditor(detectedEditor, root, databaseType, noUserManagement);
 }
 

lib/helpers/jhipster_option_helper.js

@@ -31,153 +31,153 @@ module.exports = {
   askForClassesWithJPAMetamodelFiltering
 };
 
-function askForClassesToPaginate(classes, value) {
-  return QuestionAsker.selectMultipleChoices({
+async function askForClassesToPaginate(classes, value) {
+  return await QuestionAsker.selectMultipleChoices({
     classes,
     question: `Please choose the entities you want to paginate with ${value}:`
   });
 }
 
-function askForPagination(classes, values) {
+async function askForPagination(classes, values) {
   if (!(values instanceof Array)) {
     values = [values];
   }
   const listPagination = {};
   for (let i = 0; i < values.length; i++) {
-    const classesToPaginate = askForClassesToPaginate(classes, values[i]);
+    const classesToPaginate = await askForClassesToPaginate(classes, values[i]);
     for (let j = 0; j < classesToPaginate.length; j++) {
       listPagination[classesToPaginate[j]] = values[i];
     }
   }
   return listPagination;
 }
 
-function askForClassesToService(classes, value) {
-  return QuestionAsker.selectMultipleChoices({
+async function askForClassesToService(classes, value) {
+  return await QuestionAsker.selectMultipleChoices({
     classes,
     question: `Please choose the entities you want to add a service ${value ? `with ${value}` : ''}:`
   });
 }
 
-function askForService(classes, values) {
+async function askForService(classes, values) {
   if (!(values instanceof Array)) {
     values = [values];
   }
   const listService = {};
   for (let i = 0; i < values.length; i++) {
-    const classesToService = askForClassesToService(classes, values[i]);
+    const classesToService = await askForClassesToService(classes, values[i]);
     for (let j = 0; j < classesToService.length; j++) {
       listService[classesToService[j]] = values[i];
     }
   }
   return listService;
 }
 
-function askForClassesToDto(classes, value) {
-  return QuestionAsker.selectMultipleChoices({
+async function askForClassesToDto(classes, value) {
+  return await QuestionAsker.selectMultipleChoices({
     classes,
     question: `Please choose the entities you want to generate the DTO with ${value}:`
   });
 }
 
-function askForDTO(classes, values) {
+async function askForDTO(classes, values) {
   if (!(values instanceof Array)) {
     values = [values];
   }
   const listDto = {};
   for (let i = 0; i < values.length; i++) {
-    const classesToDto = askForClassesToDto(classes, values[i]);
+    const classesToDto = await askForClassesToDto(classes, values[i]);
     for (let j = 0; j < classesToDto.length; j++) {
       listDto[classesToDto[j]] = values[i];
     }
   }
   return listDto;
 }
 
-function askForClassesToSkipClientCode(classes) {
-  return QuestionAsker.selectMultipleChoices({
+async function askForClassesToSkipClientCode(classes) {
+  return await QuestionAsker.selectMultipleChoices({
     classes,
     question: 'Please choose the entities that won\'t have any client code:'
   });
 }
 
-function askForClassesWithFluentMethods(classes) {
-  return QuestionAsker.selectMultipleChoices({
+async function askForClassesWithFluentMethods(classes) {
+  return await QuestionAsker.selectMultipleChoices({
     classes,
     question: 'Please choose the entities that will have fluent methods:'
   });
 }
 
-function askForClassesWithJPAMetamodelFiltering(classes) {
-  return QuestionAsker.selectMultipleChoices({
+async function askForClassesWithJPAMetamodelFiltering(classes) {
+  return await QuestionAsker.selectMultipleChoices({
     classes,
     question: 'Please choose the entities that will be filtered (JPA metamodel filtering):'
   });
 }
 
-function askForClassesToSkipServerCode(classes) {
-  return QuestionAsker.selectMultipleChoices({
+async function askForClassesToSkipServerCode(classes) {
+  return await QuestionAsker.selectMultipleChoices({
     classes,
     question: 'Please choose the entities that won\'t have any server code:'
   });
 }
 
-function askForAngularSuffixes(classes, values) {
+async function askForAngularSuffixes(classes, values) {
   if (!(values instanceof Array)) {
     values = [values];
   }
   const angularSuffixes = {};
   for (let i = 0; i < values.length; i++) {
-    const classesToSuffix = askForAngularSuffixesClasses(classes, values[i]);
+    const classesToSuffix = await askForAngularSuffixesClasses(classes, values[i]);
     for (let j = 0; j < classesToSuffix.length; j++) {
       angularSuffixes[classesToSuffix[j]] = values[i];
     }
   }
   return angularSuffixes;
 }
 
-function askForAngularSuffixesClasses(classes, value) {
-  return QuestionAsker.selectMultipleChoices({
+async function askForAngularSuffixesClasses(classes, value) {
+  return await QuestionAsker.selectMultipleChoices({
     classes,
     question: `Please choose the entities you want to add an angular suffix with ${value}:`
   });
 }
 
-function askForMicroserviceNames(classes, values) {
+async function askForMicroserviceNames(classes, values) {
   if (!(values instanceof Array)) {
     values = [values];
   }
   const microserviceNames = {};
   for (let i = 0; i < values.length; i++) {
-    const classesToTreat = askForMicroserviceNamesClasses(classes, values[i]);
+    const classesToTreat = await askForMicroserviceNamesClasses(classes, values[i]);
     for (let j = 0; j < classesToTreat.length; j++) {
       microserviceNames[classesToTreat[j]] = values[i];
     }
   }
   return microserviceNames;
 }
 
-function askForMicroserviceNamesClasses(classes, value) {
-  return QuestionAsker.selectMultipleChoices({
+async function askForMicroserviceNamesClasses(classes, value) {
+  return await QuestionAsker.selectMultipleChoices({
     classes,
     question: `Please choose the entities included in microservice ${value}:`
   });
 }
 
-function askForClassesToBeSearched(classes, value) {
-  return QuestionAsker.selectMultipleChoices({
+async function askForClassesToBeSearched(classes, value) {
+  return await QuestionAsker.selectMultipleChoices({
     classes,
     question: `Please choose the entities that can be searched with ${value}:`
   });
 }
 
-function askForSearchEngines(classes, values) {
+async function askForSearchEngines(classes, values) {
   if (!(values instanceof Array)) {
     values = [values];
   }
   const listSearchEngine = {};
   for (let i = 0; i < values.length; i++) {
-    const classesToSearch = askForClassesToBeSearched(classes, values[i]);
+    const classesToSearch = await askForClassesToBeSearched(classes, values[i]);
     for (let j = 0; j < classesToSearch.length; j++) {
       listSearchEngine[classesToSearch[j]] = values[i];
     }

lib/helpers/question_asker.js

@@ -17,7 +17,6 @@
  * limitations under the License.
  */
 const inquirer = require('inquirer');
-const deasync = require('deasync');
 const merge = require('jhipster-core').ObjectUtils.merge;
 
 module.exports = {
@@ -55,22 +54,18 @@ const DEFAULTS = {
  * @param args {object} keys: question, defaultValue
  * @return {boolean} the user's answer.
  */
-function askConfirmation(args) {
+async function askConfirmation(args) {
   let userAnswer = 'no-answer';
   const merged = merge(DEFAULTS.CONFIRMATIONS, args);
-  inquirer.prompt([
+  const answers = await inquirer.prompt([
     {
       type: DEFAULTS.QUESTION_TYPES.CONFIRM,
       name: 'choice',
       message: merged.question,
       default: merged.defaultValue
     }
-  ]).then((answer) => {
-    userAnswer = answer.choice;
-  });
-  while (userAnswer === 'no-answer') {
-    wait(100);
-  }
+  ]);
+  userAnswer = answers.choice;
   return userAnswer;
 }
 
@@ -79,35 +74,32 @@ function askConfirmation(args) {
  * @param args {object} keys: classes, choices, question, filterFunction
  * @return the choice.
  */
-function selectMultipleChoices(args) {
+async function selectMultipleChoices(args) {
+	const result = await asyncfuncSelectMultipleChoices(args);
+	return result;
+}
+
+async function asyncfuncSelectMultipleChoices(args) {
   args.choices = args.choices || prepareChoices(args.classes);
-  let result = null;
   const merged = merge(DEFAULTS.MULTIPLE_CHOICES, args);
-  inquirer.prompt([
+  const answers = await inquirer.prompt([
     {
       type: DEFAULTS.QUESTION_TYPES.CHECKBOX,
       name: 'answer',
       message: merged.question,
       choices: merged.choices,
       filter: merged.filterFunction
     }
-  ]).then((answers) => {
-    if (answers.answer.length === 0) {
+  ]);
+  let result;
+  if (answers.answer.length === 0) {
       result = DEFAULTS.NOTHING;
     } else {
       result = answers.answer;
     }
-  });
-  while (!result) {
-    wait(100);
-  }
   return result;
 }
 
 function prepareChoices(classes) {
   return Object.keys(classes).map(classId => classes[classId].name);
 }
-
-function wait(time) {
-  deasync.sleep(time);
-}