netlify-cli 14.3.0 → 15.0.0-rc.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "netlify-cli",
   "description": "Netlify command line tool",
-  "version": "14.3.0",
+  "version": "15.0.0-rc.0",
   "author": "Netlify Inc.",
   "type": "module",
   "engines": {
@@ -44,13 +44,13 @@
   "dependencies": {
     "@bugsnag/js": "^7.20.0",
     "@fastify/static": "^6.6.0",
-    "@netlify/build": "^29.10.0",
-    "@netlify/build-info": "^7.0.0-pre-20230424.0",
-    "@netlify/config": "^20.4.0",
+    "@netlify/build": "^29.10.1",
+    "@netlify/build-info": "^7.0.0-pre-20230425.0",
+    "@netlify/config": "^20.4.1",
     "@netlify/edge-bundler": "^8.13.2",
-    "@netlify/framework-info": "^9.8.5",
+    "@netlify/framework-info": "^9.8.6",
     "@netlify/local-functions-proxy": "^1.1.1",
-    "@netlify/zip-it-and-ship-it": "^8.10.0",
+    "@netlify/zip-it-and-ship-it": "^9.2.1",
     "@octokit/rest": "^19.0.0",
     "ansi-escapes": "^6.0.0",
     "ansi-styles": "^5.0.0",
@@ -113,9 +113,8 @@
     "log-update": "^5.0.0",
     "minimist": "^1.2.5",
     "multiparty": "^4.2.1",
-    "netlify": "^13.1.4",
+    "netlify": "^13.1.5",
     "netlify-headers-parser": "^7.1.2",
-    "netlify-onegraph-internal": "0.10.1",
     "netlify-redirect-parser": "^14.1.2",
     "netlify-redirector": "^0.4.0",
     "node-fetch": "^2.6.0",

package/src/commands/build/build.mjs

@@ -3,7 +3,6 @@ import process from 'process'
 
 import { getBuildOptions, runBuild } from '../../lib/build.mjs'
 import { error, exit, getToken } from '../../utils/command-helpers.mjs'
-import { generateNetlifyGraphJWT } from '../../utils/dev.mjs'
 import { getEnvelopeEnv, normalizeContext } from '../../utils/env/index.mjs'
 
 /**
@@ -19,35 +18,13 @@ const checkOptions = ({ cachedConfig: { siteInfo = {} }, token }) => {
   }
 }
 
-const injectEnv = async function (command, { api, buildOptions, context, site, siteInfo }) {
+const injectEnv = async function (command, { api, buildOptions, context, siteInfo }) {
   const isUsingEnvelope = siteInfo && siteInfo.use_envelope
-  const authlifyTokenId = siteInfo && siteInfo.authlify_token_id
 
   const { env } = buildOptions.cachedConfig
   if (isUsingEnvelope) {
     buildOptions.cachedConfig.env = await getEnvelopeEnv({ api, context, env, siteInfo })
   }
-
-  if (authlifyTokenId) {
-    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,
-      siteId: site.id,
-    }
-
-    const netlifyGraphJWT = generateNetlifyGraphJWT(netlifyGraphConfig)
-
-    if (netlifyGraphJWT != null) {
-      // XXX(anmonteiro): this name is deprecated. Delete after 3/31/2022
-      const varData = { sources: ['general'], value: netlifyGraphJWT }
-      buildOptions.cachedConfig.env.ONEGRAPH_AUTHLIFY_TOKEN = varData
-      buildOptions.cachedConfig.env.NETLIFY_GRAPH_TOKEN = varData
-    }
-  }
 }
 
 /**

package/src/commands/dev/dev.mjs

@@ -21,7 +21,6 @@ import detectServerSettings, { getConfigWithPlugins } from '../../utils/detect-s
 import { getDotEnvVariables, getSiteInformation, injectEnvVariables } from '../../utils/dev.mjs'
 import { getEnvelopeEnv, normalizeContext } from '../../utils/env/index.mjs'
 import { ensureNetlifyIgnore } from '../../utils/gitignore.mjs'
-import { startNetlifyGraph, startPollingForAPIAuthentication } from '../../utils/graph.mjs'
 import { startLiveTunnel } from '../../utils/live-tunnel.mjs'
 import openBrowser from '../../utils/open-browser.mjs'
 import { generateInspectSettings, startProxyServer } from '../../utils/proxy-server.mjs'
@@ -124,12 +123,7 @@ const dev = async (options, command) => {
     exit(1)
   }
 
-  command.setAnalyticsPayload({ projectType: settings.framework || 'custom', live: options.live, graph: options.graph })
-
-  const startNetlifyGraphWatcher = Boolean(options.graph)
-  if (startNetlifyGraphWatcher) {
-    startPollingForAPIAuthentication({ api, command, config, site, siteInfo })
-  }
+  command.setAnalyticsPayload({ projectType: settings.framework || 'custom', live: options.live })
 
   const liveTunnelUrl = await handleLiveTunnel({ options, site, api, settings })
   const url = liveTunnelUrl || getProxyUrl(settings)
@@ -201,16 +195,6 @@ const dev = async (options, command) => {
     await openBrowser({ url, silentBrowserNoneError: true })
   }
 
-  await startNetlifyGraph({
-    command,
-    config,
-    options,
-    settings,
-    site,
-    startNetlifyGraphWatcher,
-    state,
-  })
-
   printBanner({ url })
 }
 
@@ -271,14 +255,6 @@ export const createDevCommand = (program) => {
         .argParser((value) => Number.parseInt(value))
         .hideHelp(),
     )
-    .addOption(new Option('--graph', 'enable Netlify Graph support').hideHelp())
-    .addOption(
-      new Option(
-        '--sessionId [sessionId]',
-        'Old, prefer --session-id. (Graph) connect to cloud session with ID [sessionId]',
-      ).hideHelp(true),
-    )
-    .option('--session-id [sessionId]', '(Graph) connect to cloud session with ID [sessionId]')
     .addOption(
       new Option(
         '-e, --edgeInspect [address]',
@@ -318,7 +294,6 @@ export const createDevCommand = (program) => {
       'netlify dev -d public',
       'netlify dev -c "hugo server -w" --target-port 1313',
       'netlify dev --context production',
-      'netlify dev --graph',
       'netlify dev --edge-inspect',
       'netlify dev --edge-inspect=127.0.0.1:9229',
       'netlify dev --edge-inspect-brk',

package/src/commands/main.mjs

@@ -20,7 +20,6 @@ import { createDeployCommand } from './deploy/index.mjs'
 import { createDevCommand } from './dev/index.mjs'
 import { createEnvCommand } from './env/index.mjs'
 import { createFunctionsCommand } from './functions/index.mjs'
-import { createGraphCommand } from './graph/index.mjs'
 import { createInitCommand } from './init/index.mjs'
 import { createLinkCommand } from './link/index.mjs'
 import { createLmCommand } from './lm/index.mjs'
@@ -167,7 +166,6 @@ export const createMainCommand = () => {
   createEnvCommand(program)
   createFunctionsCommand(program)
   createRecipesCommand(program)
-  createGraphCommand(program)
   createInitCommand(program)
   createLinkCommand(program)
   createLmCommand(program)

package/src/commands/serve/serve.mjs

@@ -80,7 +80,7 @@ const serve = async (options, command) => {
     exit(1)
   }
 
-  command.setAnalyticsPayload({ projectType: settings.framework || 'custom', live: options.live, graph: options.graph })
+  command.setAnalyticsPayload({ projectType: settings.framework || 'custom', live: options.live })
 
   log(`${NETLIFYDEVLOG} Building site for production`)
   log(

package/src/lib/functions/server.mjs

@@ -3,7 +3,6 @@ import { get } from 'dot-prop'
 import jwtDecode from 'jwt-decode'
 
 import { NETLIFYDEVERR, NETLIFYDEVLOG, error as errorExit, log } from '../../utils/command-helpers.mjs'
-import { generateNetlifyGraphJWT } from '../../utils/dev.mjs'
 import { CLOCKWORK_USERAGENT, getFunctionsDistPath, getInternalFunctionsDir } from '../../utils/functions/index.mjs'
 
 import { handleBackgroundFunction, handleBackgroundFunctionResult } from './background.mjs'
@@ -49,7 +48,7 @@ const hasBody = (req) =>
   (typeof req.body === 'string' || Buffer.isBuffer(req.body))
 
 export const createHandler = function (options) {
-  const { config, functionsRegistry } = options
+  const { functionsRegistry } = options
 
   return async function handler(request, response) {
     // handle proxies without path re-writes (http-servr)
@@ -115,14 +114,6 @@ export const createHandler = function (options) {
       rawQuery,
     }
 
-    if (config && config.netlifyGraphConfig && config.netlifyGraphConfig.authlifyTokenId != null) {
-      // XXX(anmonteiro): this name is deprecated. Delete after 3/31/2022
-      const jwt = generateNetlifyGraphJWT(config.netlifyGraphConfig)
-      event.authlifyToken = jwt
-      event.netlifyGraphToken = jwt
-      event.headers['X-Nf-Graph-Token'] = jwt
-    }
-
     const clientContext = buildClientContext(request.headers) || {}
 
     if (func.isBackground) {

package/src/utils/dev.mjs

@@ -3,7 +3,6 @@ import process from 'process'
 
 import { get } from 'dot-prop'
 import getPort from 'get-port'
-import jwt from 'jsonwebtoken'
 import isEmpty from 'lodash/isEmpty.js'
 
 import { supportsBackgroundFunctions } from '../lib/account.mjs'
@@ -207,27 +206,6 @@ export const acquirePort = async ({ configuredPort, defaultPort, errorMessage })
   return acquiredPort
 }
 
-// Generates a Netlify Graph JWT with the following claims:
-// - site_id
-// - netlify_token -- the bearer token for the Netlify API
-// - authlify_token_id -- the authlify token ID stored for the site after
-//   enabling API Authentication.
-export const generateNetlifyGraphJWT = ({ authlifyTokenId, netlifyToken, siteId }) => {
-  const claims = {
-    netlify_token: netlifyToken,
-    authlify_token_id: authlifyTokenId,
-    site_id: siteId,
-  }
-
-  return jwt.sign(
-    { 'https://netlify.com/jwt/claims': claims },
-    // doesn't matter. OneGraph doesn't check the signature. The presence of
-    // the Netlify API bearer token is enough because we've authenticated the
-    // user through `command.authenticate()`
-    'NOT_SIGNED',
-  )
-}
-
 export const processOnExit = (fn) => {
   const signals = ['SIGINT', 'SIGTERM', 'SIGQUIT', 'SIGHUP', 'exit']
   signals.forEach((signal) => {

package/src/commands/graph/graph-config-write.mjs

@@ -1,56 +0,0 @@
-// @ts-check
-import fs from 'fs'
-import path from 'path'
-import process from 'process'
-
-import { getNetlifyGraphConfig } from '../../lib/one-graph/cli-netlify-graph.mjs'
-import { NETLIFYDEVERR, chalk, error, log } from '../../utils/command-helpers.mjs'
-
-/**
- * Creates the `netlify graph:config:write` command
- * @param {import('commander').OptionValues} options
- * @param {import('../base-command.mjs').default} command
- * @returns
- */
-const graphConfigWrite = async (options, command) => {
-  const { site } = command.netlify
-
-  if (!site.id) {
-    error(
-      `${NETLIFYDEVERR} Warning: no siteId defined, unable to start Netlify Graph. To enable, run ${chalk.yellow(
-        'netlify init',
-      )} or ${chalk.yellow('netlify link')}`,
-    )
-  }
-
-  const netlifyGraphConfig = await getNetlifyGraphConfig({ command, options })
-
-  const schemaPath = netlifyGraphConfig.graphQLSchemaFilename.join('/')
-
-  // Support tools that looks for the schema under different keys
-  const graphQLConfig = {
-    schema: [schemaPath],
-    schemaPath: [schemaPath],
-  }
-
-  const filePath = path.resolve(...netlifyGraphConfig.graphQLConfigJsonFilename)
-  fs.writeFileSync(filePath, JSON.stringify(graphQLConfig, null, 2))
-
-  const relativePath = path.relative(process.cwd(), filePath)
-  log(`Wrote ${chalk.cyan(relativePath)}`)
-}
-
-/**
- * Creates the `netlify graph:config:write` command
- * @param {import('../base-command.mjs').default} program
- * @returns
- */
-export const createGraphConfigWriteCommand = (program) =>
-  program
-    .command('graph:config:write')
-    .description(
-      'Write a .graphqlrc.json file to the current directory for use with local tooling (e.g. the graphql extension for vscode)',
-    )
-    .action(async (options, command) => {
-      await graphConfigWrite(options, command)
-    })

package/src/commands/graph/graph-edit.mjs

@@ -1,104 +0,0 @@
-// @ts-check
-import gitRepoInfo from 'git-repo-info'
-
-import { OneGraphCliClient, ensureCLISession, upsertMergeCLISessionMetadata } from '../../lib/one-graph/cli-client.mjs'
-import {
-  defaultExampleOperationsDoc,
-  getGraphEditUrlBySiteId,
-  getNetlifyGraphConfig,
-  readGraphQLOperationsSourceFile,
-} from '../../lib/one-graph/cli-netlify-graph.mjs'
-import { NETLIFYDEVERR, chalk, error, log } from '../../utils/command-helpers.mjs'
-import openBrowser from '../../utils/open-browser.mjs'
-
-const { ensureAppForSite, executeCreatePersistedQueryMutation } = OneGraphCliClient
-
-/**
- * Creates the `netlify graph:edit` command
- * @param {import('commander').OptionValues} options
- * @param {import('../base-command.mjs').default} command
- * @returns
- */
-const graphEdit = async (options, command) => {
-  const { config, site, state } = command.netlify
-  const siteId = site.id
-
-  if (!site.id) {
-    error(
-      `${NETLIFYDEVERR} Warning: no siteId defined, unable to start Netlify Graph. To enable, run ${chalk.yellow(
-        'netlify init',
-      )} or ${chalk.yellow('netlify link')}`,
-    )
-  }
-  const netlifyGraphConfig = await getNetlifyGraphConfig({ command, options })
-
-  let graphqlDocument = readGraphQLOperationsSourceFile(netlifyGraphConfig)
-
-  if (graphqlDocument.trim().length === 0) {
-    graphqlDocument = defaultExampleOperationsDoc
-  }
-
-  const netlifyToken = await command.authenticate()
-  const { jwt } = await OneGraphCliClient.getGraphJwtForSite({ siteId, nfToken: netlifyToken })
-
-  await ensureAppForSite(netlifyToken, siteId)
-
-  const oneGraphSessionId = await ensureCLISession({
-    config,
-    metadata: {},
-    netlifyToken,
-    site,
-    state,
-    netlifyGraphConfig,
-  })
-
-  const { branch } = gitRepoInfo()
-  const persistedResult = await executeCreatePersistedQueryMutation(
-    {
-      nfToken: netlifyToken,
-      appId: siteId,
-      description: 'Temporary snapshot of local queries',
-      query: graphqlDocument,
-      tags: ['netlify-cli', `session:${oneGraphSessionId}`, `git-branch:${branch}`],
-    },
-    {
-      accessToken: jwt,
-      siteId,
-    },
-  )
-
-  const persistedDoc =
-    persistedResult.data &&
-    persistedResult.data.oneGraph &&
-    persistedResult.data.oneGraph.createPersistedQuery &&
-    persistedResult.data.oneGraph.createPersistedQuery.persistedQuery
-
-  const newMetadata = { docId: persistedDoc.id }
-
-  await upsertMergeCLISessionMetadata({
-    config,
-    jwt,
-    siteId,
-    siteRoot: site.root,
-    oneGraphSessionId,
-    newMetadata,
-  })
-
-  const graphEditUrl = getGraphEditUrlBySiteId({ siteId, oneGraphSessionId })
-
-  log(`Opening graph:edit session at ${chalk.cyan(graphEditUrl)}`)
-  await openBrowser({ url: graphEditUrl })
-}
-
-/**
- * Creates the `netlify graph:edit` command
- * @param {import('../base-command.mjs').default} program
- * @returns
- */
-export const createGraphEditCommand = (program) =>
-  program
-    .command('graph:edit')
-    .description('Launch the browser to edit your local graph functions from Netlify')
-    .action(async (options, command) => {
-      await graphEdit(options, command)
-    })

package/src/commands/graph/graph-handler.mjs

@@ -1,102 +0,0 @@
-/* eslint-disable eslint-comments/disable-enable-pair */
-// @ts-check
-
-import {
-  autocompleteCodegenModules,
-  autocompleteOperationNames,
-  buildSchema,
-  generateHandlerByOperationName,
-  getCodegenFunctionById,
-  getCodegenModule,
-  getNetlifyGraphConfig,
-  readGraphQLSchemaFile,
-} from '../../lib/one-graph/cli-netlify-graph.mjs'
-import { error, log } from '../../utils/command-helpers.mjs'
-
-/**
- * Creates the `netlify graph:handler` command
- * @param {import('commander').OptionValues} options
- * @param {import('../base-command.mjs').default} command
- * @returns
- */
-const graphHandler = async (args, options, command) => {
-  const netlifyGraphConfig = await getNetlifyGraphConfig({ command, options })
-  const { config } = command.netlify
-
-  const schemaString = readGraphQLSchemaFile(netlifyGraphConfig)
-
-  let schema
-
-  try {
-    schema = buildSchema(schemaString)
-  } catch (buildSchemaError) {
-    error(`Error parsing schema: ${buildSchemaError}`)
-  }
-
-  const userOperationNames = args.operationNames
-  const userCodegenId = options.codegen
-
-  const handlerOptions = options.data ? JSON.parse(options.data) : {}
-
-  let operationNames = userOperationNames
-  if (!operationNames || operationNames.length === 0) {
-    const operationName = await autocompleteOperationNames({ netlifyGraphConfig })
-    operationNames = [operationName]
-  }
-
-  if (!operationNames || operationNames.length === 0) {
-    error(`No operation name provided`)
-  }
-
-  const codegenModule = await getCodegenModule({ config })
-  if (!codegenModule) {
-    error(
-      `No Netlify Graph codegen module specified in netlify.toml under the [graph] header. Please specify 'codeGenerator' field and try again.`,
-    )
-    return
-  }
-
-  let codeGenerator = userCodegenId ? await getCodegenFunctionById({ config, id: userCodegenId }) : null
-  if (!codeGenerator) {
-    codeGenerator = await autocompleteCodegenModules({ config })
-  }
-
-  if (!codeGenerator) {
-    error(`Unable to select appropriate Netlify Graph code generator`)
-    return
-  }
-
-  if (schema) {
-    /* eslint-disable fp/no-loops */
-    for (const operationName of operationNames) {
-      await generateHandlerByOperationName({
-        generate: codeGenerator.generateHandler,
-        logger: log,
-        netlifyGraphConfig,
-        schema,
-        operationName,
-        handlerOptions,
-      })
-    }
-  } else {
-    error(`Failed to parse Netlify GraphQL schema`)
-  }
-}
-
-/**
- * Creates the `netlify graph:handler` command
- * @param {import('../base-command.mjs').default} program
- * @returns
- */
-export const createGraphHandlerCommand = (program) =>
-  program
-    .command('graph:handler')
-    .argument('[name...]', 'Operation name(s)')
-    .option('-c, --codegen <id>', 'The id of the specific code generator to use')
-    .option("-d, --data '<json>'", 'Optional data to pass along to the code generator')
-    .description(
-      'Generate a handler for a Graph operation given its name. See `graph:operations` for a list of operations.',
-    )
-    .action(async (operationNames, options, command) => {
-      await graphHandler({ operationNames }, options, command)
-    })

package/src/commands/graph/graph-init.mjs

@@ -1,163 +0,0 @@
-// @ts-check
-import { Buffer } from 'buffer'
-import process from 'process'
-
-import { OneGraphClient } from 'netlify-onegraph-internal'
-import { v4 as uuidv4 } from 'uuid'
-
-import { OneGraphCliClient, ensureCLISession } from '../../lib/one-graph/cli-client.mjs'
-import { getNetlifyGraphConfig } from '../../lib/one-graph/cli-netlify-graph.mjs'
-import { NETLIFYDEVERR, chalk, error, exit, getToken, log } from '../../utils/command-helpers.mjs'
-import { translateFromEnvelopeToMongo } from '../../utils/env/index.mjs'
-
-const { ensureAppForSite, executeCreateApiTokenMutation } = OneGraphCliClient
-
-/**
- * Creates the `netlify graph:init` command
- * @param {import('commander').OptionValues} options
- * @param {import('../base-command.mjs').default} command
- * @returns
- */
-const graphInit = async (options, command) => {
-  const { api, config, site, siteInfo, state } = command.netlify
-  const accountId = siteInfo.account_slug
-  const siteId = site.id
-
-  if (!siteId) {
-    error(
-      `${NETLIFYDEVERR} Warning: no siteId defined, unable to start Netlify Graph. To enable, run ${chalk.yellow(
-        'netlify init',
-      )} or ${chalk.yellow('netlify link')}`,
-    )
-  }
-
-  let [netlifyToken] = await getToken()
-  if (!netlifyToken) {
-    netlifyToken = await command.authenticate()
-  }
-
-  if (netlifyToken == null) {
-    error(
-      `${NETLIFYDEVERR} Error: Unable to start Netlify Graph without a login. To enable, run ${chalk.yellow(
-        'netlify login',
-      )} first`,
-    )
-    return exit()
-  }
-
-  await ensureAppForSite(netlifyToken, siteId)
-
-  const netlifyGraphConfig = await getNetlifyGraphConfig({ command, options })
-
-  if (process.env.NODE_ENV !== 'test') {
-    await ensureCLISession({
-      config,
-      metadata: {},
-      netlifyToken,
-      site,
-      state,
-      netlifyGraphConfig,
-    })
-  }
-
-  let envChanged = false
-
-  // Get current environment variables set in the UI
-  let env = (siteInfo.build_settings && siteInfo.build_settings.env) || {}
-  const isUsingEnvelope = siteInfo.use_envelope
-  if (isUsingEnvelope) {
-    const envelopeVariables = await api.getEnvVars({ accountId, siteId })
-    env = translateFromEnvelopeToMongo(envelopeVariables)
-  }
-
-  const newEnv = {
-    ...env,
-  }
-
-  if (!env.NETLIFY_GRAPH_WEBHOOK_SECRET) {
-    envChanged = true
-    const secret = Buffer.from(uuidv4()).toString('base64')
-    newEnv.NETLIFY_GRAPH_WEBHOOK_SECRET = secret
-  }
-
-  if (!env.NETLIFY_GRAPH_PERSIST_QUERY_TOKEN) {
-    const variables = {
-      input: {
-        appId: siteId,
-        scopes: ['MODIFY_SCHEMA', 'PERSIST_QUERY'],
-      },
-    }
-
-    const { jwt } = await OneGraphClient.getGraphJwtForSite({ siteId, nfToken: netlifyToken })
-    const result = await executeCreateApiTokenMutation(variables, {
-      siteId,
-      accessToken: jwt,
-    })
-
-    const token =
-      result.data &&
-      result.data.oneGraph &&
-      result.data.oneGraph.createApiToken &&
-      result.data.oneGraph.createApiToken.accessToken &&
-      result.data.oneGraph.createApiToken.accessToken.token
-
-    if (token) {
-      envChanged = true
-      newEnv.NETLIFY_GRAPH_PERSIST_QUERY_TOKEN = token
-    } else {
-      error(`Unable to create Netlify Graph persist query token: ${JSON.stringify(result.errors, null, 2)}`)
-    }
-  }
-
-  if (!envChanged) {
-    log(`Graph-related environment variables already set for site ${siteInfo.name}`)
-    return true
-  }
-
-  // Apply environment variable updates
-
-  // eslint-disable-next-line unicorn/prefer-ternary
-  if (isUsingEnvelope) {
-    await api.createEnvVars({
-      accountId,
-      siteId,
-      body: [
-        !env.NETLIFY_GRAPH_WEBHOOK_SECRET && {
-          key: 'NETLIFY_GRAPH_WEBHOOK_SECRET',
-          scopes: ['functions'],
-          values: [{ context: 'all', value: newEnv.NETLIFY_GRAPH_WEBHOOK_SECRET }],
-        },
-        !env.NETLIFY_GRAPH_PERSIST_QUERY_TOKEN && {
-          key: 'NETLIFY_GRAPH_PERSIST_QUERY_TOKEN',
-          scopes: ['builds', 'functions'],
-          values: [{ context: 'all', value: newEnv.NETLIFY_GRAPH_PERSIST_QUERY_TOKEN }],
-        },
-      ].filter(Boolean),
-    })
-  } else {
-    // @ts-ignore
-    await api.updateSite({
-      siteId,
-      body: {
-        build_settings: {
-          env: newEnv,
-        },
-      },
-    })
-  }
-
-  log(`Finished updating Graph-related environment variables for site ${siteInfo.name}`)
-}
-
-/**
- * Creates the `netlify graph:init` command
- * @param {import('../base-command.mjs').default} program
- * @returns
- */
-export const createGraphInitCommand = (program) =>
-  program
-    .command('graph:init')
-    .description('Initialize all the resources for Netlify Graph')
-    .action(async (options, command) => {
-      await graphInit(options, command)
-    })