netlify-cli 16.8.0 → 16.9.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "netlify-cli",
   "description": "Netlify command line tool",
-  "version": "16.8.0",
+  "version": "16.9.0",
   "author": "Netlify Inc.",
   "type": "module",
   "engines": {
@@ -49,6 +49,7 @@
     "@netlify/config": "20.9.0",
     "@netlify/edge-bundler": "9.3.0",
     "@netlify/local-functions-proxy": "1.1.1",
+    "@netlify/sdk": "^1.1.5",
     "@netlify/serverless-functions-api": "1.9.1",
     "@netlify/zip-it-and-ship-it": "9.25.1",
     "@octokit/rest": "19.0.13",
@@ -104,6 +105,7 @@
     "is-stream": "3.0.0",
     "is-wsl": "2.2.0",
     "isexe": "2.0.0",
+    "js-yaml": "^4.1.0",
     "jsonwebtoken": "9.0.1",
     "jwt-decode": "3.1.2",
     "lambda-local": "2.1.2",

package/src/commands/build/build.mjs

@@ -9,9 +9,11 @@ import { getEnvelopeEnv, normalizeContext } from '../../utils/env/index.mjs'
 /**
  * @param {import('../../lib/build.mjs').BuildConfig} options
  */
-const checkOptions = ({ cachedConfig: { siteInfo = {} }, token }) => {
+export const checkOptions = ({ cachedConfig: { siteInfo = {} }, token }) => {
   if (!siteInfo.id) {
-    error('Could not find the site ID. Please run netlify link.')
+    error(
+      'Could not find the site ID. If your site is not on Netlify, please run `netlify init` or `netlify deploy` first. If it is, please run `netlify link`.',
+    )
   }
 
   if (!token) {

package/src/commands/deploy/deploy.mjs

@@ -475,12 +475,13 @@ const bundleEdgeFunctions = async (options, command) => {
  *
  * @param {object} config
  * @param {boolean} config.deployToProduction
+ * @param {boolean} config.isIntegrationDeploy If the user ran netlify integration:deploy instead of just netlify deploy
  * @param {boolean} config.json If the result should be printed as json message
  * @param {boolean} config.runBuildCommand If the build command should be run
  * @param {object} config.results
  * @returns {void}
  */
-const printResults = ({ deployToProduction, json, results, runBuildCommand }) => {
+const printResults = ({ deployToProduction, isIntegrationDeploy, json, results, runBuildCommand }) => {
   const msgData = {
     'Build logs': results.logsUrl,
     'Function logs': results.functionLogsUrl,
@@ -518,7 +519,11 @@ const printResults = ({ deployToProduction, json, results, runBuildCommand }) =>
     if (!deployToProduction) {
       log()
       log('If everything looks good on your draft URL, deploy it to your main site URL with the --prod flag.')
-      log(`${chalk.cyanBright.bold(`netlify deploy${runBuildCommand ? ' --build' : ''} --prod`)}`)
+      log(
+        `${chalk.cyanBright.bold(
+          `netlify ${isIntegrationDeploy ? 'integration:' : ''}deploy${runBuildCommand ? ' --build' : ''} --prod`,
+        )}`,
+      )
       log()
     }
   }
@@ -529,7 +534,7 @@ const printResults = ({ deployToProduction, json, results, runBuildCommand }) =>
  * @param {import('commander').OptionValues} options
  * @param {import('../base-command.mjs').default} command
  */
-const deploy = async (options, command) => {
+export const deploy = async (options, command) => {
   const { workingDir } = command
   const { api, site, siteInfo } = command.netlify
   const alias = options.alias || options.branch
@@ -675,8 +680,11 @@ const deploy = async (options, command) => {
   // @ts-ignore
   await restoreConfig(configMutations, { buildDir: deployFolder, configPath, redirectsPath })
 
+  const isIntegrationDeploy = command.name() === 'integration:deploy'
+
   printResults({
     runBuildCommand: options.build,
+    isIntegrationDeploy,
     json: options.json,
     results,
     deployToProduction,

package/src/commands/integration/deploy.mjs

@@ -0,0 +1,397 @@
+/* eslint-disable import/extensions */
+import { resolve } from 'path'
+import { exit, env } from 'process'
+
+// eslint-disable-next-line n/no-missing-import
+import { getConfiguration } from '@netlify/sdk/cli-utils'
+// eslint-disable-next-line n/no-unpublished-import
+import fs from 'fs-extra'
+import inquirer from 'inquirer'
+import yaml from 'js-yaml'
+import fetch from 'node-fetch'
+
+import { getBuildOptions } from '../../lib/build.mjs'
+import { getToken, chalk, log } from '../../utils/command-helpers.mjs'
+import { getSiteInformation } from '../../utils/dev.mjs'
+import { checkOptions } from '../build/build.mjs'
+import { deploy as siteDeploy } from '../deploy/deploy.mjs'
+
+function getIntegrationAPIUrl() {
+  return env.INTEGRATION_URL || 'https://api.netlifysdk.com'
+}
+
+export function areScopesEqual(localScopes, remoteScopes) {
+  if (localScopes.length !== remoteScopes.length) {
+    return false
+  }
+
+  return localScopes.every((scope) => remoteScopes.includes(scope))
+}
+
+function logScopeConfirmationMessage(localScopes, remoteScopes) {
+  log(chalk.yellow(`This integration is already registered. The current required scopes are:`))
+  for (const scope of remoteScopes) {
+    log(chalk.green(`- ${scope}`))
+  }
+  log(chalk.yellow('and will be updated to:'))
+  for (const scope of localScopes) {
+    log(chalk.green(`- ${scope}`))
+  }
+  log(chalk.yellow('if you continue. This will only affect future installations of the integration.'))
+}
+
+function formatScopesToWrite(registeredIntegrationScopes) {
+  let scopesToWrite = {}
+
+  for (const scope of registeredIntegrationScopes) {
+    const [resource, permission] = scope.split(':')
+    if (resource === 'all') {
+      scopesToWrite = { all: true }
+      break
+    } else {
+      if (!scopesToWrite[resource]) {
+        scopesToWrite[resource] = []
+      }
+      scopesToWrite[resource].push(permission)
+    }
+  }
+  return scopesToWrite
+}
+
+function formatScopesForRemote(scopes) {
+  const scopesToWrite = []
+  if (scopes.all) {
+    scopesToWrite.push('all')
+  } else {
+    const scopeResources = Object.keys(scopes)
+    scopeResources.forEach((resource) => {
+      const permissionsRequested = scopes[resource]
+      permissionsRequested.forEach((permission) => {
+        scopesToWrite.push(`${resource}:${permission}`)
+      })
+    })
+  }
+  return scopesToWrite.join(',')
+}
+
+function verifyRequiredFieldsAreInConfig(name, description, scopes, integrationLevel) {
+  const missingFields = []
+
+  if (!name) {
+    missingFields.push('name')
+  }
+  if (!description) {
+    missingFields.push('description')
+  }
+  if (!scopes) {
+    missingFields.push('scopes')
+  }
+  if (!integrationLevel) {
+    missingFields.push('integrationLevel')
+  }
+  if (missingFields.length !== 0) {
+    log(
+      chalk.yellow(
+        `You are missing the following fields for the integration to be deployed: ${missingFields.join(
+          ', ',
+        )}. Please add a these fields as an entry to the integration.yaml file and try again.`,
+      ),
+    )
+    log(
+      chalk.yellow(
+        'For more information on the required fields, please see the documentation: https://ntl.fyi/create-private-integration',
+      ),
+    )
+    return false
+  }
+  return true
+}
+
+// eslint-disable-next-line max-params
+export async function registerIntegration(workingDir, siteId, accountId, localIntegrationConfig, token) {
+  const { description, integrationLevel, name, scopes, slug } = localIntegrationConfig
+  log(chalk.yellow(`An integration associated with the site ID ${siteId} is not registered.`))
+  const registerPrompt = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'registerIntegration',
+      message: `Would you like to register this site as a private integration now?`,
+      default: false,
+    },
+  ])
+
+  if (!registerPrompt.registerIntegration) {
+    log(
+      chalk.white(
+        "Cancelling deployment. Please run 'netlify int deploy' again when you are ready to register the integration.",
+      ),
+    )
+    log(
+      chalk.white(
+        "You can also register the integration through the Netlify UI on the 'Integrations' > 'Create private integration' page",
+      ),
+    )
+    exit(1)
+  }
+
+  if (!verifyRequiredFieldsAreInConfig(name, description, scopes, integrationLevel)) {
+    exit(1)
+  }
+
+  log(chalk.white('Registering the integration...'))
+
+  const { body, statusCode } = await fetch(`${getIntegrationAPIUrl()}/${accountId}/integrations`, {
+    method: 'POST',
+    headers: {
+      'netlify-token': token,
+    },
+    body: JSON.stringify({
+      name,
+      slug,
+      description,
+      hostSiteId: siteId,
+      scopes: formatScopesForRemote(scopes),
+      integrationLevel,
+    }),
+  }).then(async (res) => {
+    const response = await res.json()
+    return { body: response, statusCode: res.status }
+  })
+
+  if (statusCode !== 201) {
+    log(chalk.red(`There was an error registering the integration:`))
+    log()
+    log(chalk.red(`-----------------------------------------------`))
+    log(chalk.red(body.msg))
+    log(chalk.red(`-----------------------------------------------`))
+    log()
+    log(chalk.red(`Please try again. If the problem persists, please contact support.`))
+    exit(1)
+  }
+
+  log(chalk.green(`Successfully registered the integration with the slug: ${body.slug}`))
+
+  const updatedIntegrationConfig = yaml.dump({
+    config: { name, description, slug: body.slug, scopes, integrationLevel },
+  })
+
+  const filePath = resolve(workingDir, 'integration.yaml')
+  await fs.writeFile(filePath, updatedIntegrationConfig)
+
+  log(chalk.yellow('Your integration.yaml file has been updated. Please commit and push these changes.'))
+}
+
+// eslint-disable-next-line max-params
+export async function updateIntegration(
+  workingDir,
+  options,
+  siteId,
+  accountId,
+  localIntegrationConfig,
+  token,
+  registeredIntegration,
+) {
+  let { description, integrationLevel, name, scopes, slug } = localIntegrationConfig
+
+  let integrationSlug = slug
+  if (slug !== registeredIntegration.slug) {
+    // Update the project's integration.yaml file with the remote slug since that will
+    // be considered the source of truth and is a value that can't be edited by the user.
+    // Let the user know they need to commit and push the changes.
+    integrationSlug = registeredIntegration.slug
+  }
+
+  if (!name) {
+    // Disabling this lint rule because the destructuring was not assigning the variable correct and leading to a bug
+    // eslint-disable-next-line prefer-destructuring
+    name = registeredIntegration.name
+  }
+
+  if (!description) {
+    // eslint-disable-next-line prefer-destructuring
+    description = registeredIntegration.description
+  }
+
+  if (!integrationLevel) {
+    // eslint-disable-next-line prefer-destructuring
+    integrationLevel = registeredIntegration.integrationLevel
+  }
+
+  // This is returned as a comma separated string and will be easier to manage here as an array
+  const registeredIntegrationScopes = registeredIntegration.scopes.split(',')
+
+  const scopeResources = Object.keys(scopes)
+  let localScopes = []
+
+  if (scopeResources.includes('all')) {
+    localScopes = ['all']
+  } else {
+    scopeResources.forEach((resource) => {
+      const permissionsRequested = scopes[resource]
+      permissionsRequested.forEach((permission) => {
+        localScopes.push(`${resource}:${permission}`)
+      })
+    })
+  }
+
+  if (!areScopesEqual(localScopes, registeredIntegrationScopes)) {
+    logScopeConfirmationMessage(localScopes, registeredIntegrationScopes)
+
+    const scopePrompt = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'updateScopes',
+        message: `Do you want to update the scopes?`,
+        default: false,
+      },
+    ])
+
+    let scopesToWrite
+    if (scopePrompt.updateScopes) {
+      // Update the scopes in remote
+      scopesToWrite = scopes
+      const { statusCode, updateResponse } = await fetch(
+        `${getIntegrationAPIUrl()}/${accountId}/integrations/${integrationSlug}`,
+        {
+          method: 'PUT',
+          headers: {
+            'netlify-token': token,
+          },
+          body: JSON.stringify({
+            name,
+            description,
+            hostSiteId: siteId,
+            scopes: localScopes.join(','),
+            integrationLevel,
+          }),
+        },
+      ).then(async (res) => {
+        const response = await res.json()
+        return { updateResponse: response, statusCode: res.status }
+      })
+
+      if (statusCode !== 200) {
+        log(
+          chalk.red(`There was an error updating the integration: ${updateResponse}`),
+          chalk.red('Please try again. If the problem persists, please contact support.'),
+        )
+        exit(1)
+      }
+    } else {
+      const useRegisteredScopesPrompt = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'useRegisteredScopes',
+          message: `Do you want to save the scopes registered for your integration in your local configuration file?`,
+          default: false,
+        },
+      ])
+
+      if (useRegisteredScopesPrompt.useRegisteredScopes) {
+        // Use the scopes that are already registered
+        log(chalk.white('Saving the currently registered scopes to the integration.yaml file.'))
+        scopesToWrite = formatScopesToWrite(registeredIntegrationScopes)
+      }
+
+      if (!useRegisteredScopesPrompt.useRegisteredScopes && options.prod) {
+        log(chalk.red('Unable to deploy your integration to production without updating the registered scopes.'))
+        exit(1)
+      }
+    }
+
+    const updatedIntegrationConfig = yaml.dump({
+      config: { name, description, slug: integrationSlug, scopes: scopesToWrite, integrationLevel },
+    })
+
+    const filePath = resolve(workingDir, 'integration.yaml')
+    await fs.writeFile(filePath, updatedIntegrationConfig)
+
+    log(chalk.yellow('Changes to the integration.yaml file are complete. Please commit and push these changes.'))
+  }
+}
+
+/**
+ * The deploy command for Netlify Integrations
+ * @param {import('commander').OptionValues} options
+ * * @param {import('../base-command.mjs').default} command
+ */
+const deploy = async (options, command) => {
+  const { api, cachedConfig, site, siteInfo } = command.netlify
+  const { id: siteId } = site
+  const [token] = await getToken()
+  const workingDir = resolve(command.workingDir)
+  const buildOptions = await getBuildOptions({
+    cachedConfig,
+    packagePath: command.workspacePackage,
+    token,
+    options,
+  })
+
+  // Confirm that a site is linked and that the user is logged in
+  checkOptions(buildOptions)
+
+  const { description, integrationLevel, name, scopes, slug } = await getConfiguration()
+  const localIntegrationConfig = { name, description, scopes, slug, integrationLevel }
+
+  const { accountId } = await getSiteInformation({
+    api,
+    site,
+    siteInfo,
+  })
+
+  const { body: registeredIntegration, statusCode } = await fetch(
+    `${getIntegrationAPIUrl()}/${accountId}/integrations?site_id=${siteId}`,
+    {
+      headers: {
+        'netlify-token': token,
+      },
+    },
+  ).then(async (res) => {
+    const body = await res.json()
+    return { body, statusCode: res.status }
+  })
+
+  // The integration is registered on the remote
+  statusCode === 200
+    ? await updateIntegration(
+        workingDir,
+        options,
+        siteId,
+        accountId,
+        localIntegrationConfig,
+        token,
+        registeredIntegration,
+      )
+    : await registerIntegration(workingDir, siteId, accountId, localIntegrationConfig, token)
+
+  // Set the prod flag to true if the integration is being initially registered because we don't want the user
+  // to be in a weird state where the card is appearing in the integrations list but there's no production
+  // version of the integration deployed
+  options = statusCode === 200 ? options : { ...options, prod: true }
+
+  // Deploy the integration to that site
+  await siteDeploy(options, command)
+
+  log(
+    `${chalk.cyanBright.bold(
+      `Your integration has been deployed. Next step is to enable it for a team or site.`,
+    )} https://ntl.fyi/create-private-integration`,
+  )
+}
+
+/**
+ * Creates the `netlify int deploy` command
+ * @param {import('../base-command.mjs').default} program
+ * @returns
+ */
+export const createDeployCommand = (program) =>
+  program
+    .command('integration:deploy')
+    .alias('int:deploy')
+    .description('Register, build, and deploy a private integration on Netlify')
+    .option('-p, --prod', 'Deploy to production', false)
+    .option('-b, --build', 'Build the integration', false)
+    .option('-a, --auth <token>', 'Netlify auth token to deploy with', env.NETLIFY_AUTH_TOKEN)
+    .option('-s, --site <name-or-id>', 'A site name or ID to deploy to', env.NETLIFY_SITE_ID)
+    .action(deploy)
+/* eslint-enable import/extensions */

package/src/commands/integration/index.mjs

@@ -0,0 +1,25 @@
+import { createDeployCommand } from './deploy.mjs'
+
+/**
+ * The int command
+ * @param {import('commander').OptionValues} options
+ * @param {import('../base-command.mjs').default} command
+ */
+const integrations = (options, command) => {
+  command.help()
+}
+
+/**
+ * Creates the `netlify integration` command
+ * @param {import('../base-command.mjs').default} program
+ * @returns
+ */
+export const createIntegrationCommand = (program) => {
+  createDeployCommand(program)
+
+  return program
+    .command('integration')
+    .alias('int')
+    .description('Manage Netlify Integrations built with the Netlify SDK')
+    .action(integrations)
+}

package/src/commands/main.mjs

@@ -22,6 +22,7 @@ import { createDevCommand } from './dev/index.mjs'
 import { createEnvCommand } from './env/index.mjs'
 import { createFunctionsCommand } from './functions/index.mjs'
 import { createInitCommand } from './init/index.mjs'
+import { createIntegrationCommand } from './integration/index.mjs'
 import { createLinkCommand } from './link/index.mjs'
 import { createLmCommand } from './lm/index.mjs'
 import { createLoginCommand } from './login/index.mjs'
@@ -191,6 +192,7 @@ export const createMainCommand = () => {
   createFunctionsCommand(program)
   createRecipesCommand(program)
   createInitCommand(program)
+  createIntegrationCommand(program)
   createLinkCommand(program)
   createLmCommand(program)
   createLoginCommand(program)

package/src/lib/functions/registry.mjs

@@ -1,5 +1,5 @@
 // @ts-check
-import { mkdir } from 'fs/promises'
+import { mkdir, stat } from 'fs/promises'
 import { createRequire } from 'module'
 import { basename, extname, isAbsolute, join, resolve } from 'path'
 import { env } from 'process'
@@ -39,6 +39,7 @@ export class FunctionsRegistry {
     debug = false,
     isConnected = false,
     logLambdaCompat,
+    manifest,
     projectRoot,
     settings,
     timeouts,
@@ -96,6 +97,14 @@ export class FunctionsRegistry {
      * @type {boolean}
      */
     this.logLambdaCompat = Boolean(logLambdaCompat)
+
+    /**
+     * Contents of a `manifest.json` file that can be looked up when dealing
+     * with built functions.
+     *
+     * @type {object}
+     */
+    this.manifest = manifest
   }
 
   checkTypesPackage() {
@@ -390,12 +399,30 @@ export class FunctionsRegistry {
         FunctionsRegistry.logEvent('extracted', { func })
       }
 
-      func.mainFile = join(unzippedDirectory, `${func.name}.js`)
+      // If there's a manifest file, look up the function in order to extract
+      // the build data.
+      const manifestEntry = (this.manifest?.functions || []).find((manifestFunc) => manifestFunc.name === func.name)
+
+      func.buildData = manifestEntry?.buildData || {}
+
+      // When we look at an unzipped function, we don't know whether it uses
+      // the legacy entry file format (i.e. `[function name].js`) or the new
+      // one (i.e. `___netlify-entry-point.mjs`). Let's look for the new one
+      // and use it if it exists, otherwise use the old one.
+      try {
+        const v2EntryPointPath = join(unzippedDirectory, '___netlify-entry-point.mjs')
+
+        await stat(v2EntryPointPath)
+
+        func.mainFile = v2EntryPointPath
+      } catch {
+        func.mainFile = join(unzippedDirectory, `${func.name}.js`)
+      }
+    } else {
+      this.buildFunctionAndWatchFiles(func, !isReload)
     }
 
     this.functions.set(name, func)
-
-    this.buildFunctionAndWatchFiles(func, !isReload)
   }
 
   /**

package/src/lib/functions/server.mjs

@@ -1,6 +1,7 @@
 // @ts-check
 import { Buffer } from 'buffer'
 import { promises as fs } from 'fs'
+import path from 'path'
 
 import express from 'express'
 import expressLogging from 'express-logging'
@@ -261,6 +262,7 @@ export const startFunctionsServer = async (options) => {
     options
   const internalFunctionsDir = await getInternalFunctionsDir({ base: site.root })
   const functionsDirectories = []
+  let manifest
 
   // If the `loadDistFunctions` parameter is sent, the functions server will
   // use the built functions created by zip-it-and-ship-it rather than building
@@ -270,6 +272,18 @@ export const startFunctionsServer = async (options) => {
 
     if (distPath) {
       functionsDirectories.push(distPath)
+
+      // When using built functions, read the manifest file so that we can
+      // extract metadata such as routes and API version.
+      try {
+        const manifestPath = path.join(distPath, 'manifest.json')
+        // eslint-disable-next-line unicorn/prefer-json-parse-buffer
+        const data = await fs.readFile(manifestPath, 'utf8')
+
+        manifest = JSON.parse(data)
+      } catch {
+        // no-op
+      }
     }
   } else {
     // The order of the function directories matters. Rightmost directories take
@@ -297,6 +311,7 @@ export const startFunctionsServer = async (options) => {
     debug,
     isConnected: Boolean(siteUrl),
     logLambdaCompat: isFeatureFlagEnabled('cli_log_lambda_compat', siteInfo),
+    manifest,
     // functions always need to be inside the packagePath if set inside a monorepo
     projectRoot: command.workingDir,
     settings,