feat(init): prompt to configure build settings in 'no git remote' case (#7258)

* test: add more uses of DEBUG_TESTS in mock api helper

* feat(init): prompt to configure build settings in 'no git remote' case

We currently do this in the 'happy path' case where a git remote is found (regardless of
whether the use chooses to *connect* their site to this git remote (i.e. configure Netlify
CD), but not in the case where the user chooses the "Yes, create and deploy site manually"
answer to the "Do you want to create a Netlify site without a git repository?".

It turns out this is a pretty common choice, and it's confusing that it doesn't detect and
recommend build settings for your project and prompt you to write them to a `netlify.toml`

This ports over the same flow to this scenario.

* fix(init): adjust misleading message

deploy builds by default now

Author: serhalp

src/commands/init/init.ts

@@ -11,6 +11,7 @@ import type BaseCommand from '../base-command.js'
 import { link } from '../link/link.js'
 import { sitesCreate } from '../sites/sites-create.js'
 import type { CLIState, SiteInfo } from '../../utils/types.js'
+import { getBuildSettings, saveNetlifyToml } from '../../utils/init/utils.js'
 
 const persistState = ({ siteInfo, state }: { siteInfo: SiteInfo; state: CLIState }): void => {
   // Save to .netlify/state.json file
@@ -38,15 +39,47 @@ const logExistingAndExit = ({ siteInfo }: { siteInfo: SiteInfo }): never => {
 /**
  * Creates and new site and exits the process
  */
-const createNewSiteAndExit = async ({ command, state }: { command: BaseCommand; state: CLIState }): Promise<never> => {
+const createNewSiteAndExit = async ({
+  command,
+  state,
+  disableLinking,
+}: {
+  command: BaseCommand
+  state: CLIState
+  disableLinking: boolean
+}): Promise<never> => {
   const siteInfo = await sitesCreate({}, command)
 
   log(`"${siteInfo.name}" site was created`)
   log()
-  log(`To deploy to this site. Run your site build and then ${chalk.cyanBright.bold('netlify deploy')}`)
 
   persistState({ state, siteInfo })
 
+  if (!disableLinking) {
+    const { shouldConfigureBuild } = await inquirer.prompt<{ shouldConfigureBuild: boolean }>([
+      {
+        type: 'confirm',
+        name: 'shouldConfigureBuild',
+        message: `Do you want to configure build settings? We'll suggest settings for your project automatically`,
+      },
+    ])
+    if (shouldConfigureBuild) {
+      const {
+        cachedConfig: { configPath },
+        config,
+        repositoryRoot,
+      } = command.netlify
+      const { baseDir, buildCmd, buildDir, functionsDir } = await getBuildSettings({
+        config,
+        command,
+      })
+      await saveNetlifyToml({ repositoryRoot, config, configPath, baseDir, buildCmd, buildDir, functionsDir })
+    }
+  }
+
+  log()
+  log(`To deploy to this site, run ${chalk.cyanBright.bold('netlify deploy')}`)
+
   return exit()
 }
 
@@ -90,10 +123,12 @@ const handleNoGitRemoteAndExit = async ({
   command,
   error,
   state,
+  disableLinking,
 }: {
   command: BaseCommand
   error?: unknown
   state: CLIState
+  disableLinking: boolean
 }): Promise<never> => {
   log()
   log(chalk.yellow('No git remote was found, would you like to set one up?'))
@@ -124,7 +159,7 @@ git remote add origin https://github.com/YourUserName/RepoName.git
   ])
 
   if (noGitRemoteChoice === NEW_SITE_NO_GIT) {
-    return await createNewSiteAndExit({ state, command })
+    return createNewSiteAndExit({ state, command, disableLinking })
   }
   return logGitSetupInstructionsAndExit()
 }
@@ -153,7 +188,6 @@ const createOrLinkSiteToRepo = async (command: BaseCommand) => {
     await track('sites_initStarted', {
       type: 'new site',
     })
-    // run site:create command
     return await sitesCreate({}, command)
   }
   // run link command
@@ -188,7 +222,12 @@ export const init = async (options: OptionValues, command: BaseCommand): Promise
   // Look for local repo
   const repoData = await getRepoData({ workingDir: command.workingDir, remoteName: options.gitRemoteName })
   if ('error' in repoData) {
-    return await handleNoGitRemoteAndExit({ command, error: repoData.error, state })
+    return await handleNoGitRemoteAndExit({
+      command,
+      error: repoData.error,
+      state,
+      disableLinking: options.disableLinking,
+    })
   }
 
   const siteInfo = isEmpty(existingSiteInfo) ? await createOrLinkSiteToRepo(command) : existingSiteInfo

src/utils/init/utils.ts

@@ -95,7 +95,6 @@ export const getBuildSettings = async ({
   config: NormalizedCachedConfigConfig
 }) => {
   const settings = await detectBuildSettings(command)
-  // TODO: add prompt for asking to choose the build command
   const setting: Partial<Settings> = settings.length > 0 ? settings[0] : {}
   const { defaultBaseDir, defaultBuildCmd, defaultBuildDir, defaultFunctionsDir, recommendedPlugins } =
     normalizeSettings(setting, config, command)

tests/integration/commands/init/init.test.ts

@@ -138,7 +138,7 @@ describe.concurrent('commands/init', () => {
         answer: answerWithValue(publish),
       },
       {
-        question: 'No netlify.toml detected',
+        question: 'No netlify.toml detected. Would you like to create one with these build settings?',
         answer: CONFIRM,
       },
       { question: 'Give this Netlify SSH public key access to your repository', answer: CONFIRM },
@@ -213,6 +213,89 @@ describe.concurrent('commands/init', () => {
     })
   })
 
+  test('prompts to configure build settings when no git remote is found', async (t) => {
+    const publish = 'custom-publish'
+    const initQuestions = [
+      {
+        question: 'Yes, create and deploy site manually',
+        answer: answerWithValue(CONFIRM),
+      },
+      { question: 'Team: (Use arrow keys)', answer: CONFIRM },
+      {
+        question: 'Site name (leave blank for a random name; you can change it later)',
+        answer: answerWithValue('test-site-name'),
+      },
+      {
+        question: `Do you want to configure build settings? We'll suggest settings for your project automatically`,
+        answer: answerWithValue(CONFIRM),
+      },
+      {
+        question: 'Your build command (hugo build/yarn run build/etc)',
+        answer: CONFIRM,
+      },
+      {
+        question: 'Directory to deploy (blank for current dir)',
+        answer: answerWithValue(publish),
+      },
+      {
+        question: 'No netlify.toml detected. Would you like to create one with these build settings?',
+        answer: CONFIRM,
+      },
+    ]
+
+    const routes = [
+      {
+        path: 'accounts',
+        response: [{ slug: 'test-account' }],
+      },
+      {
+        path: 'sites',
+        response: [],
+      },
+      {
+        path: 'sites/site_id',
+        response: {
+          admin_url: 'https://app.netlify.com/sites/site-name/overview',
+          ssl_url: 'https://site-name.netlify.app/',
+          id: 'site_id',
+          name: 'site-name',
+          build_settings: {},
+        },
+      },
+      {
+        path: 'user',
+        response: { name: 'test user', slug: 'test-user', email: 'user@test.com' },
+      },
+      {
+        path: 'test-account/sites',
+        method: 'POST' as const,
+        response: { id: 'site_id', name: 'test-site-name' },
+      },
+    ]
+
+    await withSiteBuilder(t, async (builder) => {
+      await builder.build()
+
+      await withMockApi(routes, async ({ apiUrl }) => {
+        const childProcess = execa(cliPath, ['init'], {
+          cwd: builder.directory,
+          env: { NETLIFY_API_URL: apiUrl, NETLIFY_AUTH_TOKEN: 'fake-token' },
+          encoding: 'utf8',
+        })
+
+        handleQuestions(childProcess, initQuestions)
+
+        await childProcess
+
+        await assertNetlifyToml(t, builder.directory, {
+          command: '# no build command',
+          functions: defaultFunctionsDirectory,
+          publish,
+        })
+      })
+    })
+  })
+
   test('netlify init new Next.js site', async (t) => {
     const [command, publish] = ['custom-build-command', 'custom-publish']
     const initQuestions = [

tests/integration/utils/handle-questions.ts

@@ -17,8 +17,6 @@ interface Process {
  * Utility to mock the stdin of the cli. You must provide the correct number of
  * questions correctly typed or the process will keep waiting for input.
  *
- * @param process
- * @param questions
  * @param prompts questions that you know the CLI will ask and respective answers to mock
  */
 export const handleQuestions = (

tests/integration/utils/mock-api.ts

@@ -56,6 +56,9 @@ export const startMockApi = ({ routes, silent }: MockApiOptions): Promise<MockAp
     app[method.toLowerCase() as 'all' | 'get' | 'post' | 'put' | 'delete' | 'patch' | 'options' | 'head'](
       `/api/v1/${path}`,
       function onRequest(req, res) {
+        if (process.env.DEBUG_TESTS) {
+          console.debug('[mock-api] ', req.method, req.path, req.body)
+        }
         // validate request body
         if (requestBody !== undefined && !isDeepStrictEqual(requestBody, req.body)) {
           res.status(500)
@@ -70,18 +73,27 @@ export const startMockApi = ({ routes, silent }: MockApiOptions): Promise<MockAp
   })
 
   app.get('/site/site_id/integrations/safe', function onRequest(req, res) {
+    if (process.env.DEBUG_TESTS) {
+      console.debug('[mock-api] ', req.method, req.path, req.body)
+    }
     addRequest(requests, req)
     res.status(200)
     res.json({ site_id: 'site_id', integrations: [] })
   })
 
   app.get('/team/account_id/integrations/installations/meta/site_id', function onRequest(req, res) {
+    if (process.env.DEBUG_TESTS) {
+      console.debug('[mock-api] ', req.method, req.path, req.body)
+    }
     addRequest(requests, req)
     res.status(200)
     res.json({ site_id: 'site_id', integrations: [] })
   })
 
   app.all('*', function onRequest(req, res) {
+    if (process.env.DEBUG_TESTS) {
+      console.debug('[mock-api] ', req.method, req.path, req.body)
+    }
     addRequest(requests, req)
     if (!silent) {
       console.warn(`Route not found: (${req.method.toUpperCase()}) ${req.url}`)