netlify-cli 14.4.0 → 15.0.0

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)
-    })

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

@@ -1,88 +0,0 @@
-// @ts-check
-import { GraphQL } from 'netlify-onegraph-internal'
-
-import { readLockfile } from '../../lib/one-graph/cli-client.mjs'
-import {
-  buildSchema,
-  defaultExampleOperationsDoc,
-  extractFunctionsFromOperationDoc,
-  generateFunctionsFile,
-  getNetlifyGraphConfig,
-  parse,
-  readGraphQLOperationsSourceFile,
-  readGraphQLSchemaFile,
-} from '../../lib/one-graph/cli-netlify-graph.mjs'
-import { NETLIFYDEVERR, chalk, error, log } from '../../utils/command-helpers.mjs'
-
-/**
- * Creates the `netlify graph:library` command
- * @param {import('commander').OptionValues} options
- * @param {import('../base-command.mjs').default} command
- * @returns
- */
-const graphLibrary = async (options, command) => {
-  const { config } = command.netlify
-  const netlifyGraphConfig = await getNetlifyGraphConfig({ command, options })
-
-  const schemaString = readGraphQLSchemaFile(netlifyGraphConfig)
-
-  let currentOperationsDoc = readGraphQLOperationsSourceFile(netlifyGraphConfig)
-  if (currentOperationsDoc.trim().length === 0) {
-    currentOperationsDoc = defaultExampleOperationsDoc
-  }
-
-  const parsedDoc = parse(currentOperationsDoc)
-  const { fragments, functions } = extractFunctionsFromOperationDoc(GraphQL, parsedDoc)
-
-  let schema
-
-  try {
-    schema = buildSchema(schemaString)
-  } catch (buildSchemaError) {
-    error(`Error parsing schema: ${buildSchemaError}`)
-  }
-
-  if (!schema) {
-    error(`Failed to parse Netlify GraphQL schema`)
-    return
-  }
-
-  const lockfile = readLockfile({ siteRoot: command.netlify.site.root })
-
-  if (lockfile === undefined) {
-    error(
-      `${NETLIFYDEVERR} Error: no lockfile found, unable to run \`netlify graph:library\`. To pull a remote schema (and create a lockfile), run ${chalk.yellow(
-        'netlify graph:pull',
-      )} `,
-    )
-    return
-  }
-
-  const { schemaId } = lockfile.locked
-
-  const payload = {
-    config,
-    logger: log,
-    netlifyGraphConfig,
-    schema,
-    schemaId,
-    operationsDoc: currentOperationsDoc,
-    functions,
-    fragments,
-  }
-
-  generateFunctionsFile(payload)
-}
-
-/**
- * Creates the `netlify graph:library` command
- * @param {import('../base-command.mjs').default} program
- * @returns
- */
-export const createGraphLibraryCommand = (program) =>
-  program
-    .command('graph:library')
-    .description('Generate the Graph function library')
-    .action(async (options, command) => {
-      await graphLibrary(options, command)
-    })

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

@@ -1,116 +0,0 @@
-// @ts-check
-import { GraphQL } from 'netlify-onegraph-internal'
-
-import {
-  defaultExampleOperationsDoc,
-  extractFunctionsFromOperationDoc,
-  getNetlifyGraphConfig,
-  readGraphQLOperationsSourceFile,
-} from '../../lib/one-graph/cli-netlify-graph.mjs'
-import { log } from '../../utils/command-helpers.mjs'
-
-const { parse } = GraphQL
-
-/**
- * Creates the `netlify graph:operations` command
- * @param {import('commander').OptionValues} options
- * @param {import('../base-command.mjs').default} command
- * @returns
- */
-const graphOperations = async (options, command) => {
-  const netlifyGraphConfig = await getNetlifyGraphConfig({ command, options })
-  try {
-    let currentOperationsDoc = readGraphQLOperationsSourceFile(netlifyGraphConfig)
-    if (currentOperationsDoc.trim().length === 0) {
-      currentOperationsDoc = defaultExampleOperationsDoc
-    }
-
-    const parsedDoc = parse(currentOperationsDoc)
-    const { fragments, functions } = extractFunctionsFromOperationDoc(GraphQL, parsedDoc)
-
-    const sorted = {
-      /** @type {import('netlify-onegraph-internal/dist/netlifyGraph').ExtractedFunction[]} */
-      queries: [],
-      /** @type {import('netlify-onegraph-internal/dist/netlifyGraph').ExtractedFunction[]} */
-      mutations: [],
-      /** @type {import('netlify-onegraph-internal/dist/netlifyGraph').ExtractedFunction[]} */
-      subscriptions: [],
-      /** @type {import('netlify-onegraph-internal/dist/netlifyGraph').ExtractedFragment[]} */
-      fragments: [],
-      /** @type {any[]} */
-      other: [],
-    }
-
-    // Sort the operations by name and add them to the correct array under the operation type in sorted
-    Object.values(functions)
-      .sort((aItem, bItem) => aItem.operationName.localeCompare(bItem.operationName))
-      .forEach((operation) => {
-        switch (operation.kind) {
-          case 'query': {
-            sorted.queries.push(operation)
-
-            break
-          }
-          case 'mutation': {
-            sorted.mutations.push(operation)
-
-            break
-          }
-          case 'subscription': {
-            sorted.subscriptions.push(operation)
-
-            break
-          }
-          default: {
-            sorted.other.push(operation)
-          }
-        }
-      })
-
-    Object.values(fragments)
-      .sort((aItem, bItem) => aItem.fragmentName.localeCompare(bItem.fragmentName))
-      .forEach((fragment) => {
-        sorted.fragments.push(fragment)
-      })
-
-    if (sorted.queries.length !== 0) {
-      log(`Queries:`)
-      sorted.queries.forEach((operation) => {
-        log(`\t${operation.operationName}`)
-      })
-    }
-    if (sorted.mutations.length !== 0) {
-      log(`Mutations:`)
-      sorted.mutations.forEach((operation) => {
-        log(`\t${operation.operationName}`)
-      })
-    }
-    if (sorted.subscriptions.length !== 0) {
-      log(`Subscriptions:`)
-      sorted.subscriptions.forEach((operation) => {
-        log(`\t${operation.operationName}`)
-      })
-    }
-    if (sorted.fragments.length !== 0) {
-      log(`Fragments:`)
-      sorted.fragments.forEach((fragment) => {
-        log(`\t${fragment.fragmentName}`)
-      })
-    }
-  } catch (error) {
-    error(`Error parsing operations library: ${error}`)
-  }
-}
-
-/**
- * Creates the `netlify graph:operations` command
- * @param {import('../base-command.mjs').default} program
- * @returns
- */
-export const createGraphOperationsCommand = (program) =>
-  program
-    .command('graph:operations')
-    .description('List all of the locally available operations')
-    .action(async (options, command) => {
-      await graphOperations(options, command)
-    })

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

@@ -1,168 +0,0 @@
-// @ts-check
-/* eslint-disable eslint-comments/disable-enable-pair */
-/* eslint-disable fp/no-loops */
-import { OneGraphClient } from 'netlify-onegraph-internal'
-
-import {
-  OneGraphCliClient,
-  ensureCLISession,
-  handleCliSessionEvent,
-  loadCLISession,
-  readLockfile,
-  readSchemaIdFromLockfile,
-  refetchAndGenerateFromOneGraph,
-} from '../../lib/one-graph/cli-client.mjs'
-import { buildSchema, getNetlifyGraphConfig, readGraphQLSchemaFile } from '../../lib/one-graph/cli-netlify-graph.mjs'
-import { NETLIFYDEVERR, chalk, error, log, warn } from '../../utils/command-helpers.mjs'
-
-/**
- * Creates the `netlify graph:pull` command
- * @param {import('commander').OptionValues} options
- * @param {import('../base-command.mjs').default} command
- * @returns
- */
-const graphPull = async (options, command) => {
-  const { config, site, state } = command.netlify
-
-  if (!site.id) {
-    error(
-      `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 netlifyToken = await command.authenticate()
-  const siteId = site.id
-
-  const { jwt } = await OneGraphCliClient.getGraphJwtForSite({ siteId, nfToken: netlifyToken })
-
-  let oneGraphSessionId = loadCLISession(state)
-  let lockfile = readLockfile({ siteRoot: command.netlify.site.root })
-
-  if (!oneGraphSessionId || !lockfile) {
-    warn(
-      'No local Netlify Graph session found, skipping command queue drain. Create a new session by running `netlify graph:edit`.',
-    )
-    oneGraphSessionId = await ensureCLISession({
-      config,
-      netlifyGraphConfig,
-      metadata: {},
-      netlifyToken,
-      site,
-      state,
-    })
-
-    lockfile = readLockfile({ siteRoot: command.netlify.site.root })
-  }
-
-  if (lockfile === undefined) {
-    error(`${NETLIFYDEVERR} Error: unable to create lockfile for site and session, exiting.`)
-    return
-  }
-
-  const { schemaId } = lockfile.locked
-
-  await refetchAndGenerateFromOneGraph({
-    config,
-    logger: log,
-    netlifyGraphConfig,
-    jwt,
-    schemaId,
-    state,
-    siteId,
-    sessionId: oneGraphSessionId,
-  })
-
-  const schemaString = readGraphQLSchemaFile(netlifyGraphConfig)
-
-  let schema
-
-  try {
-    schema = buildSchema(schemaString)
-  } catch (buildSchemaError) {
-    error(`Error parsing schema: ${buildSchemaError}`)
-  }
-
-  if (!schema) {
-    error(`Failed to fetch and update Netlify GraphQL schema`)
-  }
-
-  const next = await OneGraphCliClient.fetchCliSessionEvents({
-    appId: siteId,
-    jwt,
-    sessionId: oneGraphSessionId,
-  })
-
-  if (!next) {
-    return
-  }
-
-  if (next.errors) {
-    error(`Failed to fetch Netlify Graph cli session events: ${JSON.stringify(next.errors, null, 2)}`)
-  }
-
-  if (next.events) {
-    const ackEventIds = []
-    for (const event of next.events) {
-      try {
-        const audience = event.audience || OneGraphClient.eventAudience(event)
-
-        if (audience === 'CLI') {
-          const eventName = OneGraphClient.friendlyEventName(event)
-          log(`${chalk.magenta('Handling')} Netlify Graph: ${eventName}...`)
-          const nextSchemaId = readSchemaIdFromLockfile({ siteRoot: site.root })
-
-          if (!nextSchemaId) {
-            warn('Unable to load schemaId from Netlify Graph lockfile')
-            return
-          }
-
-          if (!schema) {
-            warn('Unable to load schema from for Netlify Graph')
-            return
-          }
-
-          await handleCliSessionEvent({
-            config,
-            netlifyToken,
-            // @ts-expect-error
-            event,
-            netlifyGraphConfig,
-            schema,
-            schemaId: nextSchemaId,
-            sessionId: oneGraphSessionId,
-            siteId: site.id,
-            siteRoot: site.root,
-          })
-          ackEventIds.push(event.id)
-        }
-      } catch (error_) {
-        warn(`Error processing individual Netlify Graph event, skipping:
-${JSON.stringify(error_, null, 2)}`)
-        ackEventIds.push(event.id)
-      }
-    }
-
-    await OneGraphCliClient.ackCLISessionEvents({
-      appId: siteId,
-      jwt,
-      sessionId: oneGraphSessionId,
-      eventIds: ackEventIds,
-    })
-  }
-}
-
-/**
- * Creates the `netlify graph:pull` command
- * @param {import('../base-command.mjs').default} program
- * @returns
- */
-export const createGraphPullCommand = (program) =>
-  program
-    .command('graph:pull')
-    .description('Pull your remote Netlify Graph schema locally, and process pending Graph edit events')
-    .action(async (options, command) => {
-      await graphPull(options, command)
-    })

package/src/commands/graph/graph.mjs

@@ -1,45 +0,0 @@
-// @ts-check
-import { warn } from '../../utils/command-helpers.mjs'
-
-import { createGraphConfigWriteCommand } from './graph-config-write.mjs'
-import { createGraphEditCommand } from './graph-edit.mjs'
-import { createGraphHandlerCommand } from './graph-handler.mjs'
-import { createGraphInitCommand } from './graph-init.mjs'
-import { createGraphLibraryCommand } from './graph-library.mjs'
-import { createGraphOperationsCommand } from './graph-operations.mjs'
-import { createGraphPullCommand } from './graph-pull.mjs'
-
-/**
- * The graph command
- * @param {import('commander').OptionValues} options
- * @param {import('../base-command.mjs').default} command
- */
-const graph = (options, command) => {
-  command.help()
-}
-
-/**
- * Creates the `netlify graph` command
- * @param {import('../base-command.mjs').default} program
- * @returns
- */
-export const createGraphCommand = (program) => {
-  createGraphConfigWriteCommand(program)
-  createGraphEditCommand(program)
-  createGraphHandlerCommand(program)
-  createGraphInitCommand(program)
-  createGraphLibraryCommand(program)
-  createGraphOperationsCommand(program)
-  createGraphPullCommand(program)
-
-  return program
-    .command('graph')
-    .hook('preAction', () => {
-      warn(
-        'Netlify Graph is deprecated and will be removed from the CLI in a future release at the end of April, 2023. Please migrate off of Netlify Graph beforehand.',
-      )
-    })
-    .description('(Deprecated) Control the Netlify Graph functions for the current site')
-    .addExamples(['netlify graph:pull', 'netlify graph:edit'])
-    .action(graph)
-}

package/src/commands/graph/index.mjs

@@ -1 +0,0 @@
-export { createGraphCommand } from './graph.mjs'