netlify-cli 12.6.0 → 12.7.0

package/src/utils/functions/functions.mjs

@@ -1,9 +1,13 @@
 // @ts-check
+import { promises as fs } from 'fs'
 import { resolve } from 'path'
 
 import { isDirectoryAsync, isFileAsync } from '../../lib/fs.mjs'
 import { getPathInProject } from '../../lib/settings.mjs'
 
+export const INTERNAL_FUNCTIONS_FOLDER = 'functions-internal'
+export const SERVE_FUNCTIONS_FOLDER = 'functions-serve'
+
 /**
  * retrieves the function directory out of the flags or config
  * @param {object} param
@@ -26,8 +30,20 @@ export const getFunctionsManifestPath = async ({ base }) => {
   return isFile ? path : null
 }
 
-export const getInternalFunctionsDir = async ({ base }) => {
-  const path = resolve(base, getPathInProject(['functions-internal']))
+export const getFunctionsDistPath = async ({ base }) => {
+  const path = resolve(base, getPathInProject(['functions']))
+  const isDirectory = await isDirectoryAsync(path)
+
+  return isDirectory ? path : null
+}
+
+export const getInternalFunctionsDir = async ({ base, ensureExists }) => {
+  const path = resolve(base, getPathInProject([INTERNAL_FUNCTIONS_FOLDER]))
+
+  if (ensureExists) {
+    await fs.mkdir(path, { recursive: true })
+  }
+
   const isDirectory = await isDirectoryAsync(path)
 
   return isDirectory ? path : null

package/src/utils/graph.mjs

@@ -0,0 +1,170 @@
+// @ts-check
+import events from 'events'
+import process from 'process'
+
+import {
+  OneGraphCliClient,
+  loadCLISession,
+  markCliSessionInactive,
+  persistNewOperationsDocForSession,
+  startOneGraphCLISession,
+} from '../lib/one-graph/cli-client.mjs'
+import {
+  defaultExampleOperationsDoc,
+  getGraphEditUrlBySiteId,
+  getNetlifyGraphConfig,
+  readGraphQLOperationsSourceFile,
+} from '../lib/one-graph/cli-netlify-graph.mjs'
+
+import { chalk, error, getToken, log, normalizeConfig, warn, watchDebounced } from './command-helpers.mjs'
+import { generateNetlifyGraphJWT, processOnExit } from './dev.mjs'
+import { addCleanupJob } from './shell.mjs'
+
+export const startPollingForAPIAuthentication = async function (options) {
+  const { api, command, config, site, siteInfo } = options
+  const frequency = 5000
+
+  const helper = async (maybeSiteData) => {
+    const siteData = await (maybeSiteData || api.getSite({ siteId: site.id }))
+    const authlifyTokenId = siteData && siteData.authlify_token_id
+
+    const existingAuthlifyTokenId = config && config.netlifyGraphConfig && config.netlifyGraphConfig.authlifyTokenId
+    if (authlifyTokenId && authlifyTokenId !== existingAuthlifyTokenId) {
+      const netlifyToken = await command.authenticate()
+      // Only inject the authlify config if a token ID exists. This prevents
+      // calling command.authenticate() (which opens a browser window) if the
+      // user hasn't enabled API Authentication
+      const netlifyGraphConfig = {
+        netlifyToken,
+        authlifyTokenId: siteData.authlify_token_id,
+        siteId: site.id,
+      }
+      config.netlifyGraphConfig = netlifyGraphConfig
+
+      const netlifyGraphJWT = generateNetlifyGraphJWT(netlifyGraphConfig)
+
+      if (netlifyGraphJWT != null) {
+        // XXX(anmonteiro): this name is deprecated. Delete after 3/31/2022
+        process.env.ONEGRAPH_AUTHLIFY_TOKEN = netlifyGraphJWT
+        process.env.NETLIFY_GRAPH_TOKEN = netlifyGraphJWT
+      }
+    } else if (!authlifyTokenId) {
+      // If there's no `authlifyTokenId`, it's because the user disabled API
+      // Auth. Delete the config in this case.
+      delete config.netlifyGraphConfig
+    }
+
+    setTimeout(helper, frequency)
+  }
+
+  await helper(siteInfo)
+}
+
+export const startNetlifyGraph = async ({
+  command,
+  config,
+  options,
+  settings,
+  site,
+  startNetlifyGraphWatcher,
+  state,
+}) => {
+  if (startNetlifyGraphWatcher && options.offline) {
+    warn(`Unable to start Netlify Graph in offline mode`)
+  } else if (startNetlifyGraphWatcher && !site.id) {
+    error(
+      `No siteId defined, unable to start Netlify Graph. To enable, run ${chalk.yellow(
+        'netlify init',
+      )} or ${chalk.yellow('netlify link')}.`,
+    )
+  } else if (startNetlifyGraphWatcher) {
+    const netlifyToken = await command.authenticate()
+    await OneGraphCliClient.ensureAppForSite(netlifyToken, site.id)
+
+    let stopWatchingCLISessions
+
+    let liveConfig = { ...config }
+    let isRestartingSession = false
+
+    const createOrResumeSession = async function () {
+      const netlifyGraphConfig = await getNetlifyGraphConfig({ command, options, settings })
+
+      let graphqlDocument = readGraphQLOperationsSourceFile(netlifyGraphConfig)
+
+      if (!graphqlDocument || graphqlDocument.trim().length === 0) {
+        graphqlDocument = defaultExampleOperationsDoc
+      }
+
+      stopWatchingCLISessions = await startOneGraphCLISession({
+        config: liveConfig,
+        netlifyGraphConfig,
+        netlifyToken,
+        site,
+        state,
+        oneGraphSessionId: options.sessionId,
+      })
+
+      // Should be created by startOneGraphCLISession
+      const oneGraphSessionId = loadCLISession(state)
+
+      await persistNewOperationsDocForSession({
+        config: liveConfig,
+        netlifyGraphConfig,
+        netlifyToken,
+        oneGraphSessionId,
+        operationsDoc: graphqlDocument,
+        siteId: site.id,
+        siteRoot: site.root,
+      })
+
+      return oneGraphSessionId
+    }
+
+    const configWatcher = new events.EventEmitter()
+
+    // Only set up a watcher if we know the config path.
+    const { configPath } = command.netlify.site
+    if (configPath) {
+      // chokidar handle
+      command.configWatcherHandle = await watchDebounced(configPath, {
+        depth: 1,
+        onChange: async () => {
+          const cwd = options.cwd || process.cwd()
+          const [token] = await getToken(options.auth)
+          const { config: newConfig } = await command.getConfig({ cwd, state, token, ...command.netlify.apiUrlOpts })
+
+          const normalizedNewConfig = normalizeConfig(newConfig)
+          configWatcher.emit('change', normalizedNewConfig)
+        },
+      })
+
+      processOnExit(async () => {
+        await command.configWatcherHandle.close()
+      })
+    }
+
+    // Set up a handler for config changes.
+    configWatcher.on('change', async (newConfig) => {
+      command.netlify.config = newConfig
+      liveConfig = newConfig
+      if (isRestartingSession) {
+        return
+      }
+      stopWatchingCLISessions && stopWatchingCLISessions()
+      isRestartingSession = true
+      await createOrResumeSession()
+      isRestartingSession = false
+    })
+
+    const oneGraphSessionId = await createOrResumeSession()
+    const cleanupSession = () => markCliSessionInactive({ netlifyToken, sessionId: oneGraphSessionId, siteId: site.id })
+
+    addCleanupJob(cleanupSession)
+
+    const graphEditUrl = getGraphEditUrlBySiteId({ siteId: site.id, oneGraphSessionId })
+
+    log(
+      `Starting Netlify Graph session, to edit your library visit ${graphEditUrl} or run \`netlify graph:edit\` in another tab`,
+    )
+  }
+}

package/src/utils/proxy-server.mjs

@@ -0,0 +1,90 @@
+// @ts-check
+import { exit, log, NETLIFYDEVERR } from './command-helpers.mjs'
+import { startProxy } from './proxy.mjs'
+
+/**
+ * @typedef {Object} InspectSettings
+ * @property {boolean} enabled - Inspect enabled
+ * @property {boolean} pause - Pause on breakpoints
+ * @property {string|undefined} address - Host/port override (optional)
+ */
+
+/**
+ * @param {boolean|string} edgeInspect
+ * @param {boolean|string} edgeInspectBrk
+ * @returns {InspectSettings}
+ */
+export const generateInspectSettings = (edgeInspect, edgeInspectBrk) => {
+  const enabled = Boolean(edgeInspect) || Boolean(edgeInspectBrk)
+  const pause = Boolean(edgeInspectBrk)
+  const getAddress = () => {
+    if (edgeInspect) {
+      return typeof edgeInspect === 'string' ? edgeInspect : undefined
+    }
+    if (edgeInspectBrk) {
+      return typeof edgeInspectBrk === 'string' ? edgeInspectBrk : undefined
+    }
+  }
+
+  return {
+    enabled,
+    pause,
+    address: getAddress(),
+  }
+}
+
+/**
+ *
+ * @param {object} params
+ * @param {*} params.addonsUrls
+ * @param {import('../commands/base-command.mjs').NetlifyOptions["config"]} params.config
+ * @param {string} [params.configPath] An override for the Netlify config path
+ * @param {import('../commands/base-command.mjs').NetlifyOptions["cachedConfig"]['env']} params.env
+ * @param {InspectSettings} params.inspectSettings
+ * @param {() => Promise<object>} params.getUpdatedConfig
+ * @param {string} params.geolocationMode
+ * @param {string} params.geoCountry
+ * @param {*} params.settings
+ * @param {boolean} params.offline
+ * @param {*} params.site
+ * @param {*} params.siteInfo
+ * @param {import('./state-config.mjs').default} params.state
+ * @returns
+ */
+export const startProxyServer = async ({
+  addonsUrls,
+  config,
+  configPath,
+  env,
+  geoCountry,
+  geolocationMode,
+  getUpdatedConfig,
+  inspectSettings,
+  offline,
+  settings,
+  site,
+  siteInfo,
+  state,
+}) => {
+  const url = await startProxy({
+    addonsUrls,
+    config,
+    configPath: configPath || site.configPath,
+    env,
+    geolocationMode,
+    geoCountry,
+    getUpdatedConfig,
+    inspectSettings,
+    offline,
+    projectDir: site.root,
+    settings,
+    state,
+    siteInfo,
+  })
+  if (!url) {
+    log(NETLIFYDEVERR, `Unable to start proxy server on port '${settings.port}'`)
+    exit(1)
+  }
+
+  return url
+}

package/src/utils/run-build.mjs

@@ -0,0 +1,129 @@
+// @ts-check
+import { promises as fs } from 'fs'
+import path from 'path'
+import process from 'process'
+
+import { INTERNAL_EDGE_FUNCTIONS_FOLDER } from '../lib/edge-functions/consts.mjs'
+import { getPathInProject } from '../lib/settings.mjs'
+
+import { error } from './command-helpers.mjs'
+import { startFrameworkServer } from './framework-server.mjs'
+import { INTERNAL_FUNCTIONS_FOLDER } from './functions/index.mjs'
+
+const netlifyBuildPromise = import('@netlify/build')
+
+// Copies `netlify.toml`, if one is defined, into the `.netlify` internal
+// directory and returns the path to its new location.
+const copyConfig = async ({ configPath, siteRoot }) => {
+  const newConfigPath = path.resolve(siteRoot, getPathInProject(['netlify.toml']))
+
+  try {
+    await fs.copyFile(configPath, newConfigPath)
+  } catch {
+    // no-op
+  }
+
+  return newConfigPath
+}
+
+const cleanInternalDirectory = async (basePath) => {
+  const ops = [INTERNAL_FUNCTIONS_FOLDER, INTERNAL_EDGE_FUNCTIONS_FOLDER, 'netlify.toml'].map((name) => {
+    const fullPath = path.resolve(basePath, getPathInProject([name]))
+
+    return fs.rm(fullPath, { force: true, recursive: true })
+  })
+
+  await Promise.all(ops)
+}
+
+const getBuildOptions = ({
+  cachedConfig,
+  options: { configPath, context, cwd = process.cwd(), debug, dry, offline, quiet, saveConfig },
+}) => ({
+  cachedConfig,
+  configPath,
+  siteId: cachedConfig.siteInfo.id,
+  token: cachedConfig.token,
+  dry,
+  debug,
+  context,
+  mode: 'cli',
+  telemetry: false,
+  buffer: false,
+  offline,
+  cwd,
+  quiet,
+  saveConfig,
+})
+
+const runNetlifyBuild = async ({ cachedConfig, options, settings, site, timeline = 'build' }) => {
+  const { default: buildSite, startDev } = await netlifyBuildPromise
+  const sharedOptions = getBuildOptions({
+    cachedConfig,
+    options,
+  })
+  const devCommand = async (settingsOverrides = {}) => {
+    const { ipVersion } = await startFrameworkServer({
+      settings: {
+        ...settings,
+        ...settingsOverrides,
+      },
+    })
+
+    settings.frameworkHost = ipVersion === 6 ? '::1' : '127.0.0.1'
+  }
+
+  if (timeline === 'build') {
+    // Start by cleaning the internal directory, as it may have artifacts left
+    // by previous builds.
+    await cleanInternalDirectory(site.root)
+
+    // Copy `netlify.toml` into the internal directory. This will be the new
+    // location of the config file for the duration of the command.
+    const tempConfigPath = await copyConfig({ configPath: cachedConfig.configPath, siteRoot: site.root })
+    const buildSiteOptions = {
+      ...sharedOptions,
+      outputConfigPath: tempConfigPath,
+      saveConfig: true,
+    }
+
+    // Run Netlify Build using the main entry point.
+    const { success } = await buildSite(buildSiteOptions)
+
+    if (!success) {
+      error('Could not start local server due to a build error')
+
+      return {}
+    }
+
+    // Start the dev server, forcing the usage of a static server as opposed to
+    // the framework server.
+    await devCommand({
+      command: undefined,
+      useStaticServer: true,
+    })
+
+    return { configPath: tempConfigPath }
+  }
+
+  const startDevOptions = {
+    ...sharedOptions,
+
+    // Set `quiet` to suppress non-essential output from Netlify Build unless
+    // the `debug` flag is set.
+    quiet: !options.debug,
+  }
+
+  // Run Netlify Build using the `startDev` entry point.
+  const { error: startDevError, success } = await startDev(devCommand, startDevOptions)
+
+  if (!success) {
+    error(`Could not start local development server\n\n${startDevError.message}\n\n${startDevError.stack}`)
+  }
+
+  return {}
+}
+
+export const runDevTimeline = (options) => runNetlifyBuild({ ...options, timeline: 'dev' })
+
+export const runBuildTimeline = (options) => runNetlifyBuild({ ...options, timeline: 'build' })

package/src/utils/shell.mjs

@@ -0,0 +1,120 @@
+// @ts-check
+import process from 'process'
+
+import execa from 'execa'
+import stripAnsiCc from 'strip-ansi-control-characters'
+
+import { chalk, log, NETLIFYDEVERR, NETLIFYDEVWARN } from './command-helpers.mjs'
+import { processOnExit } from './dev.mjs'
+
+/**
+ * @type {(() => Promise<void>)[]} - array of functions to run before the process exits
+ */
+const cleanupWork = []
+
+let cleanupStarted = false
+
+/**
+ * @param {() => Promise<void>} job
+ */
+export const addCleanupJob = (job) => {
+  cleanupWork.push(job)
+}
+
+/**
+ * @param {object} input
+ * @param {number=} input.exitCode The exit code to return when exiting the process after cleanup
+ */
+const cleanupBeforeExit = async ({ exitCode }) => {
+  // If cleanup has started, then wherever started it will be responsible for exiting
+  if (!cleanupStarted) {
+    cleanupStarted = true
+    try {
+      await Promise.all(cleanupWork.map((cleanup) => cleanup()))
+    } finally {
+      process.exit(exitCode)
+    }
+  }
+}
+
+/**
+ * Run a command and pipe stdout, stderr and stdin
+ * @param {string} command
+ * @param {NodeJS.ProcessEnv} env
+ * @returns {execa.ExecaChildProcess<string>}
+ */
+export const runCommand = (command, env = {}, spinner = null) => {
+  const commandProcess = execa.command(command, {
+    preferLocal: true,
+    // we use reject=false to avoid rejecting synchronously when the command doesn't exist
+    reject: false,
+    env,
+    // windowsHide needs to be false for child process to terminate properly on Windows
+    windowsHide: false,
+  })
+
+  // This ensures that an active spinner stays at the bottom of the commandline
+  // even though the actual framework command might be outputting stuff
+  const pipeDataWithSpinner = (writeStream, chunk) => {
+    if (spinner && spinner.isSpinning) {
+      spinner.clear()
+      spinner.isSilent = true
+    }
+    writeStream.write(chunk, () => {
+      if (spinner && spinner.isSpinning) {
+        spinner.isSilent = false
+        spinner.render()
+      }
+    })
+  }
+
+  commandProcess.stdout.pipe(stripAnsiCc.stream()).on('data', pipeDataWithSpinner.bind(null, process.stdout))
+  commandProcess.stderr.pipe(stripAnsiCc.stream()).on('data', pipeDataWithSpinner.bind(null, process.stderr))
+  process.stdin.pipe(commandProcess.stdin)
+
+  // we can't try->await->catch since we don't want to block on the framework server which
+  // is a long running process
+  // eslint-disable-next-line promise/catch-or-return
+  commandProcess
+    // eslint-disable-next-line promise/prefer-await-to-then
+    .then(async () => {
+      const result = await commandProcess
+      const [commandWithoutArgs] = command.split(' ')
+      if (result.failed && isNonExistingCommandError({ command: commandWithoutArgs, error: result })) {
+        log(
+          NETLIFYDEVERR,
+          `Failed running command: ${command}. Please verify ${chalk.magenta(`'${commandWithoutArgs}'`)} exists`,
+        )
+      } else {
+        const errorMessage = result.failed
+          ? `${NETLIFYDEVERR} ${result.shortMessage}`
+          : `${NETLIFYDEVWARN} "${command}" exited with code ${result.exitCode}`
+
+        log(`${errorMessage}. Shutting down Netlify Dev server`)
+      }
+
+      return await cleanupBeforeExit({ exitCode: 1 })
+    })
+  processOnExit(async () => await cleanupBeforeExit({}))
+
+  return commandProcess
+}
+
+const isNonExistingCommandError = ({ command, error: commandError }) => {
+  // `ENOENT` is only returned for non Windows systems
+  // See https://github.com/sindresorhus/execa/pull/447
+  if (commandError.code === 'ENOENT') {
+    return true
+  }
+
+  // if the command is a package manager we let it report the error
+  if (['yarn', 'npm'].includes(command)) {
+    return false
+  }
+
+  // this only works on English versions of Windows
+  return (
+    typeof commandError.message === 'string' &&
+    commandError.message.includes('is not recognized as an internal or external command')
+  )
+}

package/src/utils/static-server.mjs

@@ -0,0 +1,34 @@
+// @ts-check
+import path from 'path'
+
+import fastifyStatic from '@fastify/static'
+import Fastify from 'fastify'
+
+import { log, NETLIFYDEVLOG } from './command-helpers.mjs'
+
+export const startStaticServer = async ({ settings }) => {
+  const server = Fastify()
+  const rootPath = path.resolve(settings.dist)
+  server.register(fastifyStatic, {
+    root: rootPath,
+    etag: false,
+    acceptRanges: false,
+    lastModified: false,
+  })
+
+  server.setNotFoundHandler((_req, res) => {
+    res.code(404).sendFile('404.html', rootPath)
+  })
+
+  server.addHook('onRequest', (req, reply, done) => {
+    reply.header('X-Powered-by', 'netlify-dev')
+    const validMethods = ['GET', 'HEAD']
+    if (!validMethods.includes(req.method)) {
+      reply.code(405).send('Method Not Allowed')
+    }
+    done()
+  })
+
+  await server.listen({ port: settings.frameworkPort })
+  log(`\n${NETLIFYDEVLOG} Static server listening to`, settings.frameworkPort)
+}

package/src/utils/validation.mjs

@@ -0,0 +1,15 @@
+// @ts-check
+import { BANG, chalk } from './command-helpers.mjs'
+
+export const getGeoCountryArgParser = (exampleCommand) => (arg) => {
+  // Validate that the arg passed is two letters only for country
+  // See https://en.wikipedia.org/wiki/List_of_ISO_3166_country_codes
+  if (!/^[a-z]{2}$/i.test(arg)) {
+    throw new Error(
+      `The geo country code must use a two letter abbreviation.
+      ${chalk.red(BANG)}  Example:
+      ${exampleCommand}`,
+    )
+  }
+  return arg.toUpperCase()
+}