create-instantsearch-app 4.11.1 → 5.0.0

package/CHANGELOG.md

@@ -1,3 +1,60 @@
+# [5.0.0](https://github.com/algolia/create-instantsearch-app/compare/4.11.1...5.0.0) (2021-12-02)
+
+
+### Bug Fixes
+
+* **dynamicWidgets:** prevent "ais.dynamicWidgets" attribute showing up ([#542](https://github.com/algolia/create-instantsearch-app/issues/542)) ([559f705](https://github.com/algolia/create-instantsearch-app/commit/559f705ebcef48a3794efd7a588abd187d6642c9))
+
+
+### Code Refactoring
+
+* **index:** rewrite answer parsing ([#541](https://github.com/algolia/create-instantsearch-app/issues/541)) ([efd2799](https://github.com/algolia/create-instantsearch-app/commit/efd279943e23545c3c0806f8e9632ae32c83c0d6))
+
+
+### BREAKING CHANGES
+
+* **index:** the program now asks questions if some of the parameters are sent via arguments. Before this, giving an argument would cause it not to ask any questions anymore, even if they still would be useful. You can avoid this behaviour by passing --config or --no-interactive
+
+* postprocess answers
+
+* e2e installs should not have any asked questions
+
+* make e2e build test pass
+
+* more info
+
+* update to newer commander to fix the "name" issue
+
+* refactor: validate appPath like appName
+
+* error for empty string path
+
+* clean lockfile
+
+* refactor initial questions
+
+* silently check for existing answers on appName
+
+* don't ask initial questions if config is set
+
+* introduce --no-interactive, mostly for test
+
+* write tests
+
+* fix argument
+
+* undo change
+
+* make .default apply always
+
+* refactor templates to be part of initialQuestions
+
+* cover initialQuestions in tests
+
+* fix error
+
+
+
 ## [4.11.1](https://github.com/algolia/create-instantsearch-app/compare/4.11.0...4.11.1) (2021-11-18)
 
 

package/README.md

@@ -71,6 +71,7 @@ $ create-instantsearch-app --help
     --library-version <libraryVersion>                 The version of the library
     --config <config>                                  The configuration file to get the options from
     --no-installation                                  Ignore dependency installation
+    --no-interactive                                   Do not ask any interactive questions
     -h, --help                                         output usage information
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-instantsearch-app",
-  "version": "4.11.1",
+  "version": "5.0.0",
   "license": "MIT",
   "description": "⚡️ Build InstantSearch apps at the speed of thought",
   "keywords": [
@@ -39,7 +39,7 @@
     "@algolia/cache-in-memory": "4.11.0",
     "algoliasearch": "4.11.0",
     "chalk": "3.0.0",
-    "commander": "4.0.1",
+    "commander": "4.1.1",
     "inquirer": "8.0.0",
     "jstransformer-handlebars": "1.1.0",
     "latest-semver": "2.0.0",

package/src/cli/__tests__/getConfiguration.test.js

@@ -1,14 +1,8 @@
 const loadJsonFile = require('load-json-file');
-const utils = require('../../utils');
-const { getConfiguration, getLibraryVersion } = require('../getConfiguration');
+const getConfiguration = require('../getConfiguration');
 
 jest.mock('load-json-file');
 
-jest.mock('../../utils', () => ({
-  ...require.requireActual('../../utils'),
-  fetchLibraryVersions: jest.fn(() => Promise.resolve(['1.0.0'])),
-}));
-
 test('without template throws', async () => {
   expect.assertions(1);
 
@@ -36,21 +30,6 @@ test('with options from arguments and prompt merge', async () => {
   );
 });
 
-test('without stable version available', async () => {
-  utils.fetchLibraryVersions.mockImplementationOnce(() =>
-    Promise.resolve(['1.0.0-beta.0'])
-  );
-
-  const libraryVersion = await getLibraryVersion(
-    {
-      template: 'InstantSearch.js',
-    },
-    utils.getAppTemplateConfig(utils.getTemplatePath('InstantSearch.js'))
-  );
-
-  expect(libraryVersion).toBe('1.0.0-beta.0');
-});
-
 test('with config file overrides all options', async () => {
   loadJsonFile.mockImplementationOnce(x => Promise.resolve(x));
   const ignoredOptions = {

package/src/cli/__tests__/isQuestionAsked.test.js

@@ -4,30 +4,30 @@ test('with appId undefined should ask', () => {
   expect(
     isQuestionAsked({
       question: { name: 'appId', validate: input => Boolean(input) },
-      args: { appId: undefined },
+      args: { appId: undefined, interactive: true },
     })
-  ).toBe(true);
+  ).toBe(false);
 });
 
 test('with appId defined should not ask', () => {
   expect(
     isQuestionAsked({
       question: { name: 'appId', validate: input => Boolean(input) },
-      args: { appId: 'APP_ID' },
+      args: { appId: 'APP_ID', interactive: true },
     })
-  ).toBe(false);
+  ).toBe(true);
 });
 
-test('with unvalid template should ask', () => {
+test('with invalid template should ask', () => {
   expect(
     isQuestionAsked({
       question: {
         name: 'template',
         validate: () => false,
       },
-      args: { template: 'Unvalid' },
+      args: { template: 'Unvalid', interactive: true },
     })
-  ).toBe(true);
+  ).toBe(false);
 });
 
 test('with valid template should not ask', () => {
@@ -37,9 +37,9 @@ test('with valid template should not ask', () => {
         name: 'template',
         validate: () => true,
       },
-      args: { template: 'InstantSearch.js' },
+      args: { template: 'InstantSearch.js', interactive: true },
     })
-  ).toBe(false);
+  ).toBe(true);
 });
 
 test('with indexName should ask attributesToDisplay', () => {
@@ -48,7 +48,29 @@ test('with indexName should ask attributesToDisplay', () => {
       question: {
         name: 'attributesToDisplay',
       },
-      args: { indexName: 'INDEX_NAME' },
+      args: { indexName: 'INDEX_NAME', interactive: true },
     })
   ).toBe(false);
 });
+
+test('with config it does not ask', () => {
+  expect(
+    isQuestionAsked({
+      question: {
+        name: 'attributesToDisplay',
+      },
+      args: { config: '' },
+    })
+  ).toBe(true);
+});
+
+test('with --no-interactive it does not ask', () => {
+  expect(
+    isQuestionAsked({
+      question: {
+        name: 'attributesToDisplay',
+      },
+      args: { interactive: false },
+    })
+  ).toBe(true);
+});

package/src/cli/__tests__/postProcessAnswers.js

@@ -0,0 +1,111 @@
+const postProcessAnswers = require('../postProcessAnswers');
+const utils = require('../../utils');
+
+jest.mock('../../utils', () => ({
+  ...require.requireActual('../../utils'),
+  fetchLibraryVersions: jest.fn(() => Promise.resolve(['1.0.0'])),
+}));
+
+test('merges configuration and answers', async () => {
+  expect(
+    await postProcessAnswers({
+      configuration: { attributesForFaceting: ['test'], b: 1 },
+      answers: { attributesForFaceting: [] },
+      templateConfig: {},
+      optionsFromArguments: {},
+    })
+  ).toEqual(expect.objectContaining({ attributesForFaceting: [], b: 1 }));
+});
+
+describe('libraryVersion', () => {
+  test('library version from answers is used', async () => {
+    const { libraryVersion } = await postProcessAnswers({
+      configuration: {},
+      answers: {
+        template: 'InstantSearch.js',
+        attributesForFaceting: [],
+        libraryVersion: '0.1.2',
+      },
+      optionsFromArguments: {},
+      templateConfig: utils.getAppTemplateConfig(
+        utils.getTemplatePath('InstantSearch.js')
+      ),
+    });
+
+    expect(libraryVersion).toBe('0.1.2');
+  });
+
+  test('library version falls back to beta if it is the only available', async () => {
+    utils.fetchLibraryVersions.mockImplementationOnce(() =>
+      Promise.resolve(['1.0.0-beta.0'])
+    );
+
+    const { libraryVersion } = await postProcessAnswers({
+      configuration: {},
+      answers: {
+        template: 'InstantSearch.js',
+        attributesForFaceting: [],
+      },
+      optionsFromArguments: {},
+      templateConfig: utils.getAppTemplateConfig(
+        utils.getTemplatePath('InstantSearch.js')
+      ),
+    });
+
+    expect(libraryVersion).toBe('1.0.0-beta.0');
+  });
+});
+
+test('creates alternative names', async () => {
+  expect(
+    await postProcessAnswers({
+      configuration: {},
+      answers: {
+        attributesForFaceting: [],
+        organization: 'algolia',
+        name: 'date-range',
+      },
+      templateConfig: {
+        packageNamePrefix: 'instantsearch-widget-',
+      },
+      optionsFromArguments: {},
+    })
+  ).toEqual(
+    expect.objectContaining({
+      packageName: '@algolia/instantsearch-widget-date-range',
+      widgetType: 'algolia.date-range',
+      camelCaseName: 'dateRange',
+      pascalCaseName: 'DateRange',
+    })
+  );
+});
+
+test('detects dynamic widgets', async () => {
+  expect(
+    await postProcessAnswers({
+      configuration: {},
+      templateConfig: {},
+      optionsFromArguments: {},
+      answers: { attributesForFaceting: ['ais.dynamicWidgets', 'test'] },
+    })
+  ).toEqual(
+    expect.objectContaining({
+      attributesForFaceting: ['test'],
+      flags: { dynamicWidgets: true },
+    })
+  );
+
+  expect(
+    await postProcessAnswers({
+      configuration: {},
+      templateConfig: {},
+      optionsFromArguments: {},
+      answers: { attributesForFaceting: ['test'] },
+    })
+  ).toEqual(
+    expect.objectContaining({
+      attributesForFaceting: ['test'],
+      flags: { dynamicWidgets: false },
+    })
+  );
+});

package/src/cli/getAnswersDefaultValues.js

@@ -4,12 +4,10 @@ module.exports = function getAnswersDefaultValues(
   template
 ) {
   return {
+    ...configuration,
     ...optionsFromArguments,
     template,
-    attributesToDisplay:
-      configuration.attributesToDisplay &&
-      configuration.attributesToDisplay.length > 0
-        ? configuration.attributesToDisplay
-        : undefined,
+    // name has a default of '', as it's a special case in Commander
+    name: optionsFromArguments.name || configuration.name,
   };
 };

package/src/cli/getConfiguration.js

@@ -1,37 +1,4 @@
-const latestSemver = require('latest-semver');
 const loadJsonFile = require('load-json-file');
-const camelCase = require('lodash.camelcase');
-
-const { fetchLibraryVersions } = require('../utils');
-
-function capitalize(str) {
-  return str.substr(0, 1).toUpperCase() + str.substr(1);
-}
-
-function createNameAlternatives({ organization, name, templateConfig }) {
-  return {
-    packageName: `@${organization}/${templateConfig.packageNamePrefix ||
-      ''}${name}`,
-    widgetType: `${organization}.${name}`,
-    camelCaseName: camelCase(name),
-    pascalCaseName: capitalize(camelCase(name)),
-  };
-}
-
-async function getLibraryVersion(config, templateConfig) {
-  const { libraryName } = templateConfig;
-  const { libraryVersion } = config;
-
-  if (libraryName && !libraryVersion) {
-    const versions = await fetchLibraryVersions(libraryName);
-
-    // Return the latest available version when
-    // the stable version is not available
-    return latestSemver(versions) || versions[0];
-  }
-
-  return libraryVersion;
-}
 
 async function getConfiguration({ options = {}, answers = {} } = {}) {
   const config = options.config
@@ -45,8 +12,4 @@ async function getConfiguration({ options = {}, answers = {} } = {}) {
   return config;
 }
 
-module.exports = {
-  getConfiguration,
-  getLibraryVersion,
-  createNameAlternatives,
-};
+module.exports = getConfiguration;

package/src/cli/index.js

@@ -16,24 +16,22 @@ const {
   fetchLibraryVersions,
   getTemplatesByCategory,
   getTemplatePath,
+  splitArray,
 } = require('../utils');
-const getOptionsFromArguments = require('./getOptionsFromArguments');
 const getAttributesFromIndex = require('./getAttributesFromIndex');
 const getFacetsFromIndex = require('./getFacetsFromIndex');
 const getAnswersDefaultValues = require('./getAnswersDefaultValues');
 const isQuestionAsked = require('./isQuestionAsked');
-const {
-  getConfiguration,
-  getLibraryVersion,
-  createNameAlternatives,
-} = require('./getConfiguration');
+const getConfiguration = require('./getConfiguration');
+const postProcessAnswers = require('./postProcessAnswers');
 const { version } = require('../../package.json');
 
 let appPathFromArgument;
-let options = {};
 
 program
+  .storeOptionsAsProperties(false)
   .version(version, '-v, --version')
+  .name('create-instantsearch-app')
   .arguments('<project-directory>')
   .usage(`${chalk.green('<project-directory>')} [options]`)
   .option('--name <name>', 'The name of the application or widget')
@@ -42,31 +40,29 @@ program
   .option('--index-name <indexName>', 'The main index of your search')
   .option(
     '--attributes-to-display <attributesToDisplay>',
-    'The attributes of your index to display'
+    'The attributes of your index to display in hits',
+    splitArray
   )
   .option(
     '--attributes-for-faceting <attributesForFaceting>',
-    'The attributes for faceting'
+    'The attributes to display as filters',
+    splitArray
   )
   .option('--template <template>', 'The InstantSearch template to use')
   .option('--library-version <version>', 'The version of the library')
   .option('--config <config>', 'The configuration file to get the options from')
   .option('--no-installation', 'Ignore dependency installation')
-  .action((dest, opts) => {
+  .option('--no-interactive', 'Ask no interactive questions')
+  .action(dest => {
     appPathFromArgument = dest;
-    options = opts;
   })
   .parse(process.argv);
 
-const optionsFromArguments = getOptionsFromArguments(options.rawArgs || []);
-const attributesToDisplay = (optionsFromArguments.attributesToDisplay || '')
-  .split(',')
-  .filter(Boolean)
-  .map(x => x.trim());
-const attributesForFaceting = (optionsFromArguments.attributesForFaceting || '')
-  .split(',')
-  .filter(Boolean)
-  .map(x => x.trim());
+const optionsFromArguments = program.opts();
+const {
+  attributesToDisplay = [],
+  attributesForFaceting = [],
+} = optionsFromArguments;
 
 const getQuestions = ({ appName }) => ({
   application: [
@@ -160,7 +156,7 @@ const getQuestions = ({ appName }) => ({
       ],
       filter: attributes => attributes.filter(Boolean),
       when: ({ appId, apiKey, indexName }) =>
-        !attributesToDisplay.length > 0 && appId && apiKey && indexName,
+        attributesToDisplay.length === 0 && appId && apiKey && indexName,
     },
     {
       type: 'checkbox',
@@ -202,7 +198,7 @@ const getQuestions = ({ appName }) => ({
       },
       filter: attributes => attributes.filter(Boolean),
       when: ({ appId, apiKey, indexName }) =>
-        !attributesForFaceting.length > 0 && appId && apiKey && indexName,
+        attributesForFaceting.length === 0 && appId && apiKey && indexName,
     },
   ],
   widget: [
@@ -228,95 +224,141 @@ const getQuestions = ({ appName }) => ({
       },
     },
   ],
-});
+  initial: [
+    {
+      type: 'input',
+      name: 'appPath',
+      message: 'Project directory',
+      askAnswered: true,
+      validate(input) {
+        try {
+          return checkAppPath(input);
+        } catch (err) {
+          console.log();
+          console.error(err.message);
+          return false;
+        }
+      },
+      when(answers) {
+        try {
+          return (
+            answers.interactive &&
+            !answers.config &&
+            !checkAppPath(answers.appPath)
+          );
+        } catch (err) {
+          return true;
+        }
+      },
+    },
+    {
+      type: 'input',
+      name: 'appName',
+      message: 'The name of the application or widget',
+      askAnswered: true,
+      default(answers) {
+        return path.basename(answers.appPath);
+      },
+      validate(input) {
+        try {
+          return checkAppName(input);
+        } catch (err) {
+          console.log();
+          console.error(err.message);
+          return false;
+        }
+      },
+      when(answers) {
+        try {
+          return (
+            answers.interactive &&
+            !answers.config &&
+            !checkAppName(answers.appName)
+          );
+        } catch (err) {
+          return true;
+        }
+      },
+    },
+    {
+      type: 'list',
+      pageSize: 10,
+      name: 'template',
+      message: 'InstantSearch template',
+      askAnswered: true,
+      choices: () => {
+        const templatesByCategory = getTemplatesByCategory();
+
+        return Object.entries(templatesByCategory).reduce(
+          (templates, [category, values]) => [
+            ...templates,
+            new inquirer.Separator(category),
+            ...values,
+          ],
+          []
+        );
+      },
+      validate(input) {
+        // if a config is given, path is optional
+        if (optionsFromArguments.config) {
+          return true;
+        }
 
-async function run() {
-  let appPath = appPathFromArgument;
-  if (!appPath) {
-    const answers = await inquirer.prompt([
-      {
-        type: 'input',
-        name: 'appPath',
-        message: 'Project directory',
+        const isValid = Boolean(input);
+        if (!isValid) {
+          console.log('template is required');
+        }
+        return isValid;
       },
-    ]);
-    appPath = answers.appPath;
-  }
-  if (appPath.startsWith('~/')) {
-    appPath = path.join(os.homedir(), appPath.slice(2));
-  }
-  try {
-    checkAppPath(appPath);
-  } catch (err) {
-    console.error(err.message);
-    console.log();
+      when(answers) {
+        return answers.interactive && !answers.config && !answers.template;
+      },
+    },
+  ],
+});
 
-    process.exit(1);
-  }
+async function run() {
+  const args = {
+    ...optionsFromArguments,
+    appPath: appPathFromArgument,
+    appName: optionsFromArguments.name,
+  };
+  const initialQuestions = getQuestions({}).initial;
+  const initialAnswers = {
+    ...args,
+    ...(await inquirer.prompt(initialQuestions, args)),
+  };
+
+  initialQuestions.forEach(question => {
+    // .default doesn't get executed when "when" returns false
+    if (!initialAnswers[question.name] && question.default) {
+      const defaultValue = question.default(initialAnswers);
+      initialAnswers[question.name] = defaultValue;
+    }
+    if (!question.validate(initialAnswers[question.name])) {
+      process.exit(1);
+    }
+  });
 
-  let appName = optionsFromArguments.name;
-  if (!appName) {
-    appName = (
-      await inquirer.prompt([
-        {
-          type: 'input',
-          name: 'appName',
-          message: 'The name of the application or widget',
-          default: path.basename(appPath),
-        },
-      ])
-    ).appName;
+  if (initialAnswers.appPath.startsWith('~/')) {
+    initialAnswers.appPath = path.join(
+      os.homedir(),
+      initialAnswers.appPath.slice(2)
+    );
   }
 
-  try {
-    checkAppName(appName);
-  } catch (err) {
-    console.error(err.message);
-    console.log();
-
-    process.exit(1);
-  }
+  const { appPath, appName, template } = initialAnswers;
 
   console.log();
   console.log(`Creating a new InstantSearch app in ${chalk.green(appPath)}.`);
   console.log();
 
-  const { template = optionsFromArguments.template } = await inquirer.prompt(
-    [
-      {
-        type: 'list',
-        pageSize: 10,
-        name: 'template',
-        message: 'InstantSearch template',
-        choices: () => {
-          const templatesByCategory = getTemplatesByCategory();
-
-          return Object.entries(templatesByCategory).reduce(
-            (templates, [category, values]) => [
-              ...templates,
-              new inquirer.Separator(category),
-              ...values,
-            ],
-            []
-          );
-        },
-        validate(input) {
-          return Boolean(input);
-        },
-      },
-    ].filter(question =>
-      isQuestionAsked({ question, args: optionsFromArguments })
-    ),
-    optionsFromArguments
-  );
-
   const configuration = await getConfiguration({
     options: {
       ...optionsFromArguments,
       name: appName,
-      attributesToDisplay,
     },
-    answers: { template },
+    answers: initialAnswers,
   });
 
   const templatePath = getTemplatePath(configuration.template);
@@ -326,39 +368,21 @@ async function run() {
     templateConfig.category === 'Widget' ? 'widget' : 'application';
 
   const answers = await inquirer.prompt(
-    getQuestions({ appName })[implementationType].filter(question =>
-      isQuestionAsked({ question, args: optionsFromArguments })
+    getQuestions({ appName })[implementationType].filter(
+      question => !isQuestionAsked({ question, args: optionsFromArguments })
     ),
     getAnswersDefaultValues(optionsFromArguments, configuration, template)
   );
 
-  const alternativeNames = createNameAlternatives({
-    ...configuration,
-    ...answers,
-    templateConfig,
-  });
-
-  const libraryVersion = await getLibraryVersion(
-    { ...configuration, ...answers },
-    templateConfig
-  );
-
   const app = createInstantSearchApp(
     appPath,
-    {
-      ...configuration,
-      ...answers,
-      ...alternativeNames,
-      flags: {
-        dynamicWidgets:
-          Array.isArray(answers.attributesForFaceting) &&
-          answers.attributesForFaceting.includes('ais.dynamicWidgets'),
-      },
-      libraryVersion,
-      template: templatePath,
-      installation: program.installation,
-      currentYear: new Date().getFullYear(),
-    },
+    await postProcessAnswers({
+      configuration,
+      answers,
+      optionsFromArguments,
+      templatePath,
+      templateConfig,
+    }),
     templateConfig.tasks
   );
 

package/src/cli/isQuestionAsked.js

@@ -1,22 +1,15 @@
 module.exports = function isQuestionAsked({ question, args }) {
-  if (args.config) {
-    return false;
+  // if there's a config, ask no questions, even if it would be invalid
+  if (args.config || !args.interactive) {
+    return true;
   }
 
-  for (const optionName in args) {
-    if (question.name === optionName) {
-      // Skip if the arg in the command is valid
-      if (
-        !question.validate ||
-        (question.validate && question.validate(args[optionName]))
-      ) {
-        return false;
-      }
-    } else if (!question.validate) {
-      // Skip if the question is optional and not given in the command
-      return false;
-    }
+  const argument = args[question.name];
+
+  // Skip if the arg in the command is valid
+  if (question.validate) {
+    return question.validate(argument);
   }
 
-  return true;
+  return argument !== undefined;
 };

package/src/cli/postProcessAnswers.js

@@ -0,0 +1,77 @@
+const camelCase = require('lodash.camelcase');
+const latestSemver = require('latest-semver');
+
+const { fetchLibraryVersions } = require('../utils');
+
+function capitalize(str) {
+  return str.substr(0, 1).toUpperCase() + str.substr(1);
+}
+
+function createNameAlternatives({ organization, name, templateConfig }) {
+  return {
+    packageName: `@${organization}/${templateConfig.packageNamePrefix ||
+      ''}${name}`,
+    widgetType: `${organization}.${name}`,
+    camelCaseName: camelCase(name),
+    pascalCaseName: capitalize(camelCase(name)),
+  };
+}
+
+async function getLibraryVersion(config, templateConfig) {
+  const { libraryName } = templateConfig;
+  const { libraryVersion } = config;
+
+  if (libraryName && !libraryVersion) {
+    const versions = await fetchLibraryVersions(libraryName);
+
+    // Return the latest available version when
+    // the stable version is not available
+    return latestSemver(versions) || versions[0];
+  }
+
+  return libraryVersion;
+}
+
+async function postProcessAnswers({
+  configuration,
+  answers,
+  optionsFromArguments,
+  templatePath,
+  templateConfig,
+}) {
+  const combinedAnswers = {
+    ...configuration,
+    ...answers,
+  };
+
+  const alternativeNames = createNameAlternatives({
+    ...combinedAnswers,
+    templateConfig,
+  });
+
+  const libraryVersion = await getLibraryVersion(
+    combinedAnswers,
+    templateConfig
+  );
+
+  return {
+    ...combinedAnswers,
+    ...alternativeNames,
+    libraryVersion,
+    template: templatePath,
+    installation: optionsFromArguments.installation,
+    currentYear: new Date().getFullYear(),
+    attributesForFaceting:
+      Array.isArray(combinedAnswers.attributesForFaceting) &&
+      combinedAnswers.attributesForFaceting.filter(
+        attribute => attribute !== 'ais.dynamicWidgets'
+      ),
+    flags: {
+      dynamicWidgets:
+        Array.isArray(combinedAnswers.attributesForFaceting) &&
+        combinedAnswers.attributesForFaceting.includes('ais.dynamicWidgets'),
+    },
+  };
+}
+
+module.exports = postProcessAnswers;

package/src/templates/InstantSearch.js/index.html.hbs

@@ -33,9 +33,13 @@
     <div class="search-panel">
       {{#if attributesForFaceting}}
       <div class="search-panel__filters">
+        {{#if flags.dynamicWidgets}}
+        <div id="dynamic-widgets"></div>
+        {{else}}
         {{#each attributesForFaceting}}
         <div id="{{this}}-list"></div>
         {{/each}}
+        {{/if}}
       </div>
 
       {{/if}}

package/src/utils/__tests__/__snapshots__/index.test.js.snap

@@ -5,7 +5,3 @@ exports[`checkAppName throws with correct error message 1`] = `
   - name cannot start with a period
   - name can only contain URL-friendly characters"
 `;
-
-exports[`checkAppPath with existing file as path should throw with correct error 1`] = `"Could not create project at path path because a file of the same name already exists."`;
-
-exports[`checkAppPath with non empty directory as path should throw with correct error 1`] = `"Could not create project in destination folder \\"path\\" because it is not empty."`;

package/src/utils/__tests__/index.test.js

@@ -23,7 +23,7 @@ describe('checkAppName', () => {
 });
 
 describe('checkAppPath', () => {
-  describe('with non existant directory as path', () => {
+  describe('with non existing directory as path', () => {
     beforeAll(() => {
       mockExistsSync.mockImplementation(() => false);
     });
@@ -45,7 +45,11 @@ describe('checkAppPath', () => {
     });
 
     test('should throw with correct error', () => {
-      expect(() => utils.checkAppPath('path')).toThrowErrorMatchingSnapshot();
+      expect(() =>
+        utils.checkAppPath('path')
+      ).toThrowErrorMatchingInlineSnapshot(
+        `"Could not create project in destination folder \\"path\\" because it is not empty."`
+      );
     });
 
     afterAll(() => {
@@ -64,7 +68,31 @@ describe('checkAppPath', () => {
     });
 
     test('should throw with correct error', () => {
-      expect(() => utils.checkAppPath('path')).toThrowErrorMatchingSnapshot();
+      expect(() =>
+        utils.checkAppPath('path')
+      ).toThrowErrorMatchingInlineSnapshot(
+        `"Could not create project at path path because a file of the same name already exists."`
+      );
+    });
+
+    afterAll(() => {
+      mockExistsSync.mockReset();
+      mockLstatSync.mockReset();
+    });
+  });
+
+  describe('with empty string as path', () => {
+    beforeAll(() => {
+      mockExistsSync.mockImplementation(() => false);
+      mockLstatSync.mockImplementation(() => ({
+        isDirectory: () => false,
+      }));
+    });
+
+    test('should throw with correct error', () => {
+      expect(() => utils.checkAppPath('')).toThrowErrorMatchingInlineSnapshot(
+        `"Could not create project without directory"`
+      );
     });
 
     afterAll(() => {

package/src/utils/index.js

@@ -56,6 +56,10 @@ function checkAppPath(appPath) {
     }
   }
 
+  if (!appPath) {
+    throw new Error('Could not create project without directory');
+  }
+
   return true;
 }
 
@@ -126,7 +130,9 @@ function getTemplatePath(templateName) {
 }
 
 async function fetchLibraryVersions(libraryName) {
-  const library = await index.getObject(libraryName);
+  const library = await index.getObject(libraryName, {
+    attributesToRetrieve: ['versions'],
+  });
 
   return Object.keys(library.versions).reverse();
 }
@@ -147,6 +153,12 @@ async function getEarliestLibraryVersion(...args) {
   return await getLibraryVersion(...args)(semver.minSatisfying);
 }
 
+const splitArray = string =>
+  string
+    .split(',')
+    .filter(Boolean)
+    .map(x => x.trim());
+
 module.exports = {
   checkAppName,
   checkAppPath,
@@ -158,4 +170,5 @@ module.exports = {
   getAllTemplates,
   getTemplatePath,
   getTemplatesByCategory,
+  splitArray,
 };

package/src/cli/__tests__/getOptionsFromArguments.test.js

@@ -1,72 +0,0 @@
-const getOptionsFromArguments = require('../getOptionsFromArguments');
-
-test('with a single option', () => {
-  expect(getOptionsFromArguments('cmd --appId APP_ID'.split(' '))).toEqual({
-    appId: 'APP_ID',
-  });
-});
-
-test('with multiple options', () => {
-  expect(
-    getOptionsFromArguments([
-      'cmd',
-      '--appId',
-      'APP_ID',
-      '--apiKey',
-      'API_KEY',
-      '--indexName',
-      'INDEX_NAME',
-      '--template',
-      'Vue InstantSearch',
-    ])
-  ).toEqual({
-    appId: 'APP_ID',
-    apiKey: 'API_KEY',
-    indexName: 'INDEX_NAME',
-    template: 'Vue InstantSearch',
-  });
-});
-
-test('with different commands', () => {
-  expect(
-    getOptionsFromArguments(['yarn', 'start', '--appId', 'APP_ID'])
-  ).toEqual({
-    appId: 'APP_ID',
-  });
-
-  expect(
-    getOptionsFromArguments(['node', 'index', '--appId', 'APP_ID'])
-  ).toEqual({
-    appId: 'APP_ID',
-  });
-
-  expect(
-    getOptionsFromArguments([
-      'npm',
-      'init',
-      'instantsearch-app',
-      '--appId',
-      'APP_ID',
-    ])
-  ).toEqual({
-    appId: 'APP_ID',
-  });
-
-  expect(
-    getOptionsFromArguments([
-      'yarn',
-      'create',
-      'instantsearch-app',
-      '--appId',
-      'APP_ID',
-    ])
-  ).toEqual({
-    appId: 'APP_ID',
-  });
-
-  expect(
-    getOptionsFromArguments(['create-instantsearch-app', '--appId', 'APP_ID'])
-  ).toEqual({
-    appId: 'APP_ID',
-  });
-});

package/src/cli/getOptionsFromArguments.js

@@ -1,21 +0,0 @@
-const camelCase = require('lodash.camelcase');
-
-module.exports = function getOptionsFromArguments(rawArgs) {
-  let argIndex = 0;
-
-  return rawArgs.reduce((allArgs, currentArg) => {
-    argIndex++;
-
-    if (!currentArg.startsWith('--') || currentArg.startsWith('--no-')) {
-      return allArgs;
-    }
-
-    const argumentName = camelCase(currentArg.split('--')[1]);
-    const argumentValue = rawArgs[argIndex];
-
-    return {
-      ...allArgs,
-      [argumentName]: argumentValue,
-    };
-  }, {});
-};