netlify-cli 12.5.0 → 12.7.0

package/src/utils/banner.mjs

@@ -0,0 +1,17 @@
+// @ts-check
+import boxen from 'boxen'
+
+import { chalk, log, NETLIFYDEVLOG } from './command-helpers.mjs'
+
+export const printBanner = ({ url }) => {
+  const banner = chalk.bold(`${NETLIFYDEVLOG} Server now ready on ${url}`)
+
+  log(
+    boxen(banner, {
+      padding: 1,
+      margin: 1,
+      align: 'center',
+      borderColor: '#00c7b7',
+    }),
+  )
+}

package/src/utils/command-helpers.mjs

@@ -12,7 +12,7 @@ import WSL from 'is-wsl'
 import debounce from 'lodash/debounce.js'
 import terminalLink from 'terminal-link'
 
-import { clearSpinner, startSpinner } from '../lib/spinner.cjs'
+import { clearSpinner, startSpinner } from '../lib/spinner.mjs'
 
 import getGlobalConfig from './get-global-config.mjs'
 import getPackageJson from './get-package-json.mjs'

package/src/utils/detect-server-settings.mjs

@@ -11,7 +11,7 @@ import isPlainObject from 'is-plain-obj'
 
 import { NETLIFYDEVWARN, chalk, log } from './command-helpers.mjs'
 import { acquirePort } from './dev.mjs'
-import { getInternalFunctionsDir } from './functions/index.mjs'
+import { getInternalFunctionsDir } from './functions/functions.mjs'
 
 const formatProperty = (str) => chalk.magenta(`'${str}'`)
 const formatValue = (str) => chalk.green(`'${str}'`)
@@ -364,4 +364,38 @@ const formatSettingsArrForInquirer = function (frameworks) {
   return formattedArr.flat()
 }
 
+/**
+ * Returns a copy of the provided config with any plugins provided by the
+ * server settings
+ * @param {*} config
+ * @param {Partial<import('./types').ServerSettings>} settings
+ * @returns {*} Modified config
+ */
+export const getConfigWithPlugins = (config, settings) => {
+  if (!settings.plugins) {
+    return config
+  }
+
+  // If there are plugins that we should be running for this site, add them
+  // to the config as if they were declared in netlify.toml. We must check
+  // whether the plugin has already been added by another source (like the
+  // TOML file or the UI), as we don't want to run the same plugin twice.
+  const { plugins: existingPlugins = [] } = config
+  const existingPluginNames = new Set(existingPlugins.map((plugin) => plugin.package))
+  const newPlugins = settings.plugins
+    .map((pluginName) => {
+      if (existingPluginNames.has(pluginName)) {
+        return
+      }
+
+      return { package: pluginName, origin: 'config', inputs: {} }
+    })
+    .filter(Boolean)
+
+  return {
+    ...config,
+    plugins: [...newPlugins, ...config.plugins],
+  }
+}
+
 export default detectServerSettings

package/src/utils/dev.mjs

@@ -148,6 +148,10 @@ export const injectEnvVariables = async ({ devConfig, env, site }) => {
       const newSourceName = `${file} file`
       const sources = environment.has(key) ? [newSourceName, ...environment.get(key).sources] : [newSourceName]
 
+      if (sources.includes('internal')) {
+        return
+      }
+
       environment.set(key, {
         sources,
         value: fileEnv[key],
@@ -160,6 +164,7 @@ export const injectEnvVariables = async ({ devConfig, env, site }) => {
     const existsInProcess = process.env[key] !== undefined
     const [usedSource, ...overriddenSources] = existsInProcess ? ['process', ...variable.sources] : variable.sources
     const usedSourceName = getEnvSourceName(usedSource)
+    const isInternal = variable.sources.includes('internal')
 
     overriddenSources.forEach((source) => {
       const sourceName = getEnvSourceName(source)
@@ -173,17 +178,15 @@ export const injectEnvVariables = async ({ devConfig, env, site }) => {
       )
     })
 
-    if (!existsInProcess) {
-      // Omitting `general` env vars to reduce noise in the logs.
-      if (usedSource !== 'general') {
+    if (!existsInProcess || isInternal) {
+      // Omitting `general` and `internal` env vars to reduce noise in the logs.
+      if (usedSource !== 'general' && !isInternal) {
         log(`${NETLIFYDEVLOG} Injected ${usedSourceName} env var: ${chalk.yellow(key)}`)
       }
 
       process.env[key] = variable.value
     }
   }
-
-  process.env.NETLIFY_DEV = 'true'
 }
 
 export const acquirePort = async ({ configuredPort, defaultPort, errorMessage }) => {

package/src/utils/dot-env.mjs

@@ -4,7 +4,7 @@ import path from 'path'
 
 import dotenv from 'dotenv'
 
-import { isFileAsync } from '../lib/fs.cjs'
+import { isFileAsync } from '../lib/fs.mjs'
 
 import { warn } from './command-helpers.mjs'
 

package/src/utils/framework-server.mjs

@@ -0,0 +1,66 @@
+// @ts-check
+import waitPort from 'wait-port'
+
+import { startSpinner, stopSpinner } from '../lib/spinner.mjs'
+
+import { error, exit, log, NETLIFYDEVERR, NETLIFYDEVLOG } from './command-helpers.mjs'
+import { runCommand } from './shell.mjs'
+import { startStaticServer } from './static-server.mjs'
+
+// 10 minutes
+const FRAMEWORK_PORT_TIMEOUT = 6e5
+
+/**
+ * @typedef StartReturnObject
+ * @property {4 | 6 | undefined=} ipVersion The version the open port was found on
+ */
+
+/**
+ * Start a static server if the `useStaticServer` is provided or a framework specific server
+ * @param {object} config
+ * @param {Partial<import('./types').ServerSettings>} config.settings
+ * @returns {Promise<StartReturnObject>}
+ */
+export const startFrameworkServer = async function ({ settings }) {
+  if (settings.useStaticServer) {
+    if (settings.command) {
+      runCommand(settings.command, settings.env)
+    }
+    await startStaticServer({ settings })
+
+    return {}
+  }
+
+  log(`${NETLIFYDEVLOG} Starting Netlify Dev with ${settings.framework || 'custom config'}`)
+
+  const spinner = startSpinner({
+    text: `Waiting for framework port ${settings.frameworkPort}. This can be configured using the 'targetPort' property in the netlify.toml`,
+  })
+
+  runCommand(settings.command, settings.env, spinner)
+
+  let port
+  try {
+    port = await waitPort({
+      port: settings.frameworkPort,
+      host: 'localhost',
+      output: 'silent',
+      timeout: FRAMEWORK_PORT_TIMEOUT,
+      ...(settings.pollingStrategies.includes('HTTP') && { protocol: 'http' }),
+    })
+
+    if (!port.open) {
+      throw new Error(`Timed out waiting for port '${settings.frameworkPort}' to be open`)
+    }
+
+    stopSpinner({ error: false, spinner })
+  } catch (error_) {
+    stopSpinner({ error: true, spinner })
+    log(NETLIFYDEVERR, `Netlify Dev could not start or connect to localhost:${settings.frameworkPort}.`)
+    log(NETLIFYDEVERR, `Please make sure your framework server is running on port ${settings.frameworkPort}`)
+    error(error_)
+    exit(1)
+  }
+
+  return { ipVersion: port?.ipVersion }
+}

package/src/utils/functions/functions.mjs

@@ -1,8 +1,12 @@
 // @ts-check
+import { promises as fs } from 'fs'
 import { resolve } from 'path'
 
-import { isDirectoryAsync, isFileAsync } from '../../lib/fs.cjs'
-import { getPathInProject } from '../../lib/settings.cjs'
+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
@@ -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/functions/get-functions.mjs

@@ -1,5 +1,5 @@
 // @ts-check
-import { fileExistsAsync } from '../../lib/fs.cjs'
+import { fileExistsAsync } from '../../lib/fs.mjs'
 
 const getUrlPath = (functionName) => `/.netlify/functions/${functionName}`
 

package/src/utils/get-global-config.mjs

@@ -3,7 +3,7 @@ import { readFile } from 'fs/promises'
 import Configstore from 'configstore'
 import { v4 as uuidv4 } from 'uuid'
 
-import { getLegacyPathInHome, getPathInHome } from '../lib/settings.cjs'
+import { getLegacyPathInHome, getPathInHome } from '../lib/settings.mjs'
 
 const globalConfigDefaults = {
   /* disable stats from being sent to Netlify */

package/src/utils/gitignore.mjs

@@ -4,7 +4,7 @@ import path from 'path'
 
 import parseIgnore from 'parse-gitignore'
 
-import { fileExistsAsync } from '../lib/fs.cjs'
+import { fileExistsAsync } from '../lib/fs.mjs'
 
 import { log } from './command-helpers.mjs'
 

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/init/utils.mjs

@@ -6,7 +6,7 @@ import process from 'process'
 import cleanDeep from 'clean-deep'
 import inquirer from 'inquirer'
 
-import { fileExistsAsync } from '../../lib/fs.cjs'
+import { fileExistsAsync } from '../../lib/fs.mjs'
 import { normalizeBackslash } from '../../lib/path.mjs'
 import { chalk, error as failAndExit, log, warn } from '../command-helpers.mjs'
 

package/src/utils/live-tunnel.mjs

@@ -5,7 +5,7 @@ import fetch from 'node-fetch'
 import pWaitFor from 'p-wait-for'
 
 import { fetchLatestVersion, shouldFetchLatestVersion } from '../lib/exec-fetcher.mjs'
-import { getPathInHome } from '../lib/settings.cjs'
+import { getPathInHome } from '../lib/settings.mjs'
 
 import { NETLIFYDEVERR, NETLIFYDEVLOG, chalk, log } from './command-helpers.mjs'
 import execa from './execa.mjs'

package/src/utils/lm/install.mjs

@@ -11,9 +11,9 @@ import Listr from 'listr'
 import pathKey from 'path-key'
 
 import { fetchLatestVersion, shouldFetchLatestVersion } from '../../lib/exec-fetcher.mjs'
-import { fileExistsAsync } from '../../lib/fs.cjs'
+import { fileExistsAsync } from '../../lib/fs.mjs'
 import { normalizeBackslash } from '../../lib/path.mjs'
-import { getLegacyPathInHome, getPathInHome } from '../../lib/settings.cjs'
+import { getLegacyPathInHome, getPathInHome } from '../../lib/settings.mjs'
 import { chalk } from '../command-helpers.mjs'
 
 import { checkGitLFSVersionStep, checkGitVersionStep, checkLFSFiltersStep } from './steps.mjs'

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/proxy.mjs

@@ -25,7 +25,7 @@ import {
   initializeProxy as initializeEdgeFunctionsProxy,
   isEdgeFunctionsRequest,
 } from '../lib/edge-functions/proxy.mjs'
-import { fileExistsAsync, isFileAsync } from '../lib/fs.cjs'
+import { fileExistsAsync, isFileAsync } from '../lib/fs.mjs'
 import renderErrorTemplate from '../lib/render-error-template.mjs'
 
 import { NETLIFYDEVLOG, NETLIFYDEVWARN } from './command-helpers.mjs'

package/src/utils/rules-proxy.mjs

@@ -6,7 +6,7 @@ import cookie from 'cookie'
 import redirector from 'netlify-redirector'
 import pFilter from 'p-filter'
 
-import { fileExistsAsync } from '../lib/fs.cjs'
+import { fileExistsAsync } from '../lib/fs.mjs'
 
 import { NETLIFYDEVLOG } from './command-helpers.mjs'
 import { parseRedirects } from './redirects.mjs'