netlify-cli 9.0.5 → 9.3.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "netlify-cli",
   "description": "Netlify command line tool",
-  "version": "9.0.5",
+  "version": "9.3.0",
   "author": "Netlify Inc.",
   "contributors": [
     "Abraham Schilling <AbrahamSchilling@gmail.com> (https://gitlab.com/n4bb12)",
@@ -203,7 +203,7 @@
     "@netlify/framework-info": "^9.0.0",
     "@netlify/local-functions-proxy": "^1.1.1",
     "@netlify/plugin-edge-handlers": "^3.0.6",
-    "@netlify/plugins-list": "^6.9.0",
+    "@netlify/plugins-list": "^6.10.1",
     "@netlify/routing-local-proxy": "^0.34.1",
     "@netlify/zip-it-and-ship-it": "^5.7.4",
     "@octokit/rest": "^18.0.0",
@@ -270,7 +270,7 @@
     "multiparty": "^4.2.1",
     "netlify": "^11.0.0",
     "netlify-headers-parser": "^6.0.1",
-    "netlify-onegraph-internal": "0.0.32",
+    "netlify-onegraph-internal": "0.0.42",
     "netlify-redirect-parser": "^13.0.2",
     "netlify-redirector": "^0.2.1",
     "node-fetch": "^2.6.0",

package/src/commands/dev/dev.js

@@ -32,7 +32,6 @@ const {
   detectServerSettings,
   error,
   exit,
-  generateAuthlifyJWT,
   getSiteInformation,
   injectEnvVariables,
   log,
@@ -265,27 +264,7 @@ const dev = async (options, command) => {
   }
 
   const startNetlifyGraphWatcher = Boolean(options.graph)
-  let authlifyJWT
-
-  if (startNetlifyGraphWatcher) {
-    const netlifyToken = await command.authenticate()
-    authlifyJWT = generateAuthlifyJWT(netlifyToken, siteInfo.authlify_token_id, site.id)
-  }
-
-  await injectEnvVariables({
-    env: Object.assign(
-      command.netlify.cachedConfig.env,
-      authlifyJWT == null
-        ? {}
-        : {
-            ONEGRAPH_AUTHLIFY_TOKEN: {
-              sources: ['general'],
-              value: authlifyJWT,
-            },
-          },
-    ),
-    site,
-  })
+  await injectEnvVariables({ env: command.netlify.cachedConfig.env, site })
 
   const { addonsUrls, capabilities, siteUrl, timeouts } = await getSiteInformation({
     // inherited from base command --offline
@@ -306,28 +285,14 @@ const dev = async (options, command) => {
 
   command.setAnalyticsPayload({ projectType: settings.framework || 'custom', live: options.live })
 
-  let configWithAuthlify
-
-  if (siteInfo.authlify_token_id) {
-    const netlifyToken = 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
-    configWithAuthlify = Object.assign(config, {
-      authlify: {
-        netlifyToken,
-        authlifyTokenId: siteInfo.authlify_token_id,
-        siteId: site.id,
-      },
-    })
-  } else {
-    configWithAuthlify = config
-  }
-
   await startFunctionsServer({
-    config: configWithAuthlify,
+    api,
+    command,
+    config,
+    isGraphEnabled: startNetlifyGraphWatcher,
     settings,
     site,
+    siteInfo,
     siteUrl,
     capabilities,
     timeouts,

package/src/commands/functions/functions-serve.js

@@ -34,8 +34,10 @@ const functionsServe = async (options, command) => {
 
   await startFunctionsServer({
     config,
+    api,
     settings: { functions: functionsDir, functionsPort },
     site,
+    siteInfo,
     siteUrl,
     capabilities,
     timeouts,

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

@@ -0,0 +1,55 @@
+// @ts-check
+const fs = require('fs')
+const path = require('path')
+
+const { getNetlifyGraphConfig } = require('../../lib/one-graph/cli-netlify-graph')
+const { NETLIFYDEVERR, chalk, error } = require('../../utils')
+
+/**
+ * Creates the `netlify graph:config:write` command
+ * @param {import('commander').OptionValues} options
+ * @param {import('../base-command').BaseCommand} 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))
+}
+
+/**
+ * Creates the `netlify graph:config:write` command
+ * @param {import('../base-command').BaseCommand} program
+ * @returns
+ */
+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)
+    })
+
+module.exports = { createGraphConfigWriteCommand }

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

@@ -1,7 +1,13 @@
 // @ts-check
 const gitRepoInfo = require('git-repo-info')
 
-const { OneGraphCliClient, generateSessionName, loadCLISession } = require('../../lib/one-graph/cli-client')
+const {
+  OneGraphCliClient,
+  createCLISession,
+  generateSessionName,
+  loadCLISession,
+  upsertMergeCLISessionMetadata,
+} = require('../../lib/one-graph/cli-client')
 const {
   defaultExampleOperationsDoc,
   getGraphEditUrlBySiteId,
@@ -11,7 +17,7 @@ const {
 const { NETLIFYDEVERR, chalk, error } = require('../../utils')
 const { openBrowser } = require('../../utils/open-browser')
 
-const { createCLISession, createPersistedQuery, ensureAppForSite, updateCLISessionMetadata } = OneGraphCliClient
+const { createPersistedQuery, ensureAppForSite } = OneGraphCliClient
 
 /**
  * Creates the `netlify graph:edit` command
@@ -32,8 +38,6 @@ const graphEdit = async (options, command) => {
   }
   const netlifyGraphConfig = await getNetlifyGraphConfig({ command, options })
 
-  const { branch } = gitRepoInfo()
-
   let graphqlDocument = readGraphQLOperationsSourceFile(netlifyGraphConfig)
 
   if (graphqlDocument.trim().length === 0) {
@@ -47,11 +51,12 @@ const graphEdit = async (options, command) => {
   let oneGraphSessionId = loadCLISession(state)
   if (!oneGraphSessionId) {
     const sessionName = generateSessionName()
-    const oneGraphSession = await createCLISession(netlifyToken, site.id, sessionName, null)
+    const oneGraphSession = await createCLISession({ netlifyToken, siteId: site.id, sessionName, metadata: {} })
     state.set('oneGraphSessionId', oneGraphSession.id)
     oneGraphSessionId = state.get('oneGraphSessionId')
   }
 
+  const { branch } = gitRepoInfo()
   const persistedDoc = await createPersistedQuery(netlifyToken, {
     appId: siteId,
     description: 'Temporary snapshot of local queries',
@@ -59,7 +64,16 @@ const graphEdit = async (options, command) => {
     tags: ['netlify-cli', `session:${oneGraphSessionId}`, `git-branch:${branch}`],
   })
 
-  await updateCLISessionMetadata(netlifyToken, siteId, oneGraphSessionId, { docId: persistedDoc.id })
+  const newMetadata = { docId: persistedDoc.id }
+
+  await upsertMergeCLISessionMetadata({
+    netlifyGraphConfig,
+    netlifyToken,
+    siteId,
+    siteRoot: site.root,
+    oneGraphSessionId,
+    newMetadata,
+  })
 
   const graphEditUrl = getGraphEditUrlBySiteId({ siteId, oneGraphSessionId })
 

package/src/commands/graph/graph.js

@@ -1,4 +1,5 @@
 // @ts-check
+const { createGraphConfigWriteCommand } = require('./graph-config-write')
 const { createGraphEditCommand } = require('./graph-edit')
 const { createGraphHandlerCommand } = require('./graph-handler')
 const { createGraphLibraryCommand } = require('./graph-library')
@@ -20,6 +21,7 @@ const graph = (options, command) => {
  * @returns
  */
 const createGraphCommand = (program) => {
+  createGraphConfigWriteCommand(program)
   createGraphEditCommand(program)
   createGraphHandlerCommand(program)
   createGraphLibraryCommand(program)

package/src/lib/functions/server.js

@@ -1,4 +1,6 @@
 // @ts-check
+const process = require('process')
+
 const jwtDecode = require('jwt-decode')
 
 const {
@@ -6,7 +8,7 @@ const {
   NETLIFYDEVERR,
   NETLIFYDEVLOG,
   error: errorExit,
-  generateAuthlifyJWT,
+  generateNetlifyGraphJWT,
   getInternalFunctionsDir,
   log,
 } = require('../../utils')
@@ -45,7 +47,51 @@ const buildClientContext = function (headers) {
   }
 }
 
-const createHandler = function ({ config, functionsRegistry }) {
+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 {
+      delete config.authlify
+    }
+
+    setTimeout(helper, frequency)
+  }
+
+  await helper(siteInfo)
+}
+
+const createHandler = function (options) {
+  const { config, functionsRegistry } = options
+
+  if (options.isGraphEnabled) {
+    startPollingForAPIAuthentication(options)
+  }
+
   return async function handler(request, response) {
     // handle proxies without path re-writes (http-servr)
     const cleanPath = request.path.replace(/^\/.netlify\/(functions|builders)/, '')
@@ -107,8 +153,10 @@ const createHandler = function ({ config, functionsRegistry }) {
     }
 
     if (config && config.authlify && config.authlify.authlifyTokenId != null) {
-      const { authlifyTokenId, netlifyToken, siteId } = config.authlify
-      event.authlifyToken = generateAuthlifyJWT(netlifyToken, authlifyTokenId, siteId)
+      // XXX(anmonteiro): this name is deprecated. Delete after 3/31/2022
+      const jwt = generateNetlifyGraphJWT(config.netlifyGraphConfig)
+      event.authlifyToken = jwt
+      event.netlifyGraphToken = jwt
     }
 
     const clientContext = buildClientContext(request.headers) || {}
@@ -160,14 +208,15 @@ const createHandler = function ({ config, functionsRegistry }) {
   }
 }
 
-const getFunctionsServer = function ({ buildersPrefix, config, functionsPrefix, functionsRegistry, siteUrl }) {
+const getFunctionsServer = function (options) {
+  const { buildersPrefix = '', functionsPrefix = '', functionsRegistry, siteUrl } = options
   // performance optimization, load express on demand
   // eslint-disable-next-line node/global-require
   const express = require('express')
   // eslint-disable-next-line node/global-require
   const expressLogging = require('express-logging')
   const app = express()
-  const functionHandler = createHandler({ config, functionsRegistry })
+  const functionHandler = createHandler(options)
 
   app.set('query parser', 'simple')
 
@@ -195,16 +244,8 @@ const getFunctionsServer = function ({ buildersPrefix, config, functionsPrefix,
   return app
 }
 
-const startFunctionsServer = async ({
-  buildersPrefix = '',
-  capabilities,
-  config,
-  functionsPrefix = '',
-  settings,
-  site,
-  siteUrl,
-  timeouts,
-}) => {
+const startFunctionsServer = async (options) => {
+  const { capabilities, config, settings, site, siteUrl, timeouts } = options
   const internalFunctionsDir = await getInternalFunctionsDir({ base: site.root })
 
   // The order of the function directories matters. Leftmost directories take
@@ -223,13 +264,7 @@ const startFunctionsServer = async ({
 
     await functionsRegistry.scan(functionsDirectories)
 
-    const server = getFunctionsServer({
-      config,
-      functionsRegistry,
-      siteUrl,
-      functionsPrefix,
-      buildersPrefix,
-    })
+    const server = getFunctionsServer(Object.assign(options, { functionsRegistry }))
 
     await startWebServer({ server, settings })
   }

package/src/lib/one-graph/cli-client.js

@@ -16,6 +16,7 @@ const { watchDebounced } = require('../functions/watcher')
 const {
   generateFunctionsFile,
   generateHandlerByOperationId,
+  normalizeOperationsDoc,
   readGraphQLOperationsSourceFile,
   writeGraphQLOperationsSourceFile,
   writeGraphQLSchemaFile,
@@ -23,7 +24,7 @@ const {
 
 const { parse } = GraphQL
 const { defaultExampleOperationsDoc, extractFunctionsFromOperationDoc } = NetlifyGraph
-const { createCLISession, createPersistedQuery, ensureAppForSite, updateCLISessionMetadata } = OneGraphClient
+const { createPersistedQuery, ensureAppForSite, updateCLISessionMetadata } = OneGraphClient
 
 const internalConsole = {
   log,
@@ -231,7 +232,8 @@ const updateGraphQLOperationsFileFromPersistedDoc = async (input) => {
     return
   }
 
-  const doc = persistedDoc.query
+  // Sorts the operations stably, prepends the @netlify directive, etc.
+  const doc = normalizeOperationsDoc(persistedDoc.query)
 
   writeGraphQLOperationsSourceFile(netlifyGraphConfig, doc)
   regenerateFunctionsFileFromOperationsFile({ netlifyGraphConfig, schema })
@@ -282,9 +284,89 @@ const handleCliSessionEvent = async ({ event, netlifyGraphConfig, netlifyToken,
   }
 }
 
-const persistNewOperationsDocForSession = async ({ netlifyToken, oneGraphSessionId, operationsDoc, siteId }) => {
+/**
+ *
+ * @param {object} input
+ * @param {string} input.netlifyToken The (typically netlify) access token that is used for authentication, if any
+ * @param {string} input.oneGraphSessionId The id of the cli session to fetch the current metadata for
+ * @param {object} input.siteId The site object that contains the root file path for the site
+ */
+const getCLISession = async ({ netlifyToken, oneGraphSessionId, siteId }) => {
+  const input = {
+    appId: siteId,
+    sessionId: oneGraphSessionId,
+    authToken: netlifyToken,
+    desiredEventCount: 1,
+  }
+  return await OneGraphClient.fetchCliSession(input)
+}
+
+/**
+ *
+ * @param {object} input
+ * @param {string} input.netlifyToken The (typically netlify) access token that is used for authentication, if any
+ * @param {string} input.oneGraphSessionId The id of the cli session to fetch the current metadata for
+ * @param {string} input.siteId The site object that contains the root file path for the site
+ */
+const getCLISessionMetadata = async ({ netlifyToken, oneGraphSessionId, siteId }) => {
+  const { errors, session } = await getCLISession({ netlifyToken, oneGraphSessionId, siteId })
+  return { metadata: session && session.metadata, errors }
+}
+
+/**
+ * Look at the current project, filesystem, etc. and determine relevant metadata for a cli session
+ * @param {object} input
+ * @param {string} input.siteRoot The root file path for the site
+ * @returns {Record<string, any>} Any locally detected facts that are relevant to include in the cli session metadata
+ */
+const detectLocalCLISessionMetadata = ({ siteRoot }) => {
   const { branch } = gitRepoInfo()
+  const hostname = os.hostname()
+  const userInfo = os.userInfo({ encoding: 'utf-8' })
+  const { username } = userInfo
+
+  const detectedMetadata = {
+    gitBranch: branch,
+    hostname,
+    username,
+    siteRoot,
+  }
 
+  return detectedMetadata
+}
+
+/**
+ * Fetch the existing cli session metadata if it exists, and mutate it remotely with the passed in metadata
+ * @param {object} input
+ * @param {NetlifyGraph.NetlifyGraphConfig} input.netlifyGraphConfig The (typically netlify) access token that is used for authentication, if any
+ * @param {string} input.netlifyToken The (typically netlify) access token that is used for authentication, if any
+ * @param {string} input.oneGraphSessionId The id of the cli session to fetch the current metadata for
+ * @param {string} input.siteId The site object that contains the root file path for the site
+ * @param {string} input.siteRoot The root file path for the site
+ * @param {object} input.newMetadata The metadata to merge into (with priority) the existing metadata
+ * @returns {Promise<object>}
+ */
+const upsertMergeCLISessionMetadata = async ({ netlifyToken, newMetadata, oneGraphSessionId, siteId, siteRoot }) => {
+  const { errors, metadata } = await getCLISessionMetadata({ netlifyToken, oneGraphSessionId, siteId })
+  if (errors) {
+    warn(`Error fetching cli session metadata: ${JSON.stringify(errors, null, 2)}`)
+  }
+
+  const detectedMetadata = detectLocalCLISessionMetadata({ siteRoot })
+
+  const finalMetadata = { ...metadata, ...detectedMetadata, ...newMetadata }
+  return OneGraphClient.updateCLISessionMetadata(netlifyToken, siteId, oneGraphSessionId, finalMetadata)
+}
+
+const persistNewOperationsDocForSession = async ({
+  netlifyGraphConfig,
+  netlifyToken,
+  oneGraphSessionId,
+  operationsDoc,
+  siteId,
+  siteRoot,
+}) => {
+  const { branch } = gitRepoInfo()
   const payload = {
     appId: siteId,
     description: 'Temporary snapshot of local queries',
@@ -293,13 +375,25 @@ const persistNewOperationsDocForSession = async ({ netlifyToken, oneGraphSession
   }
   const persistedDoc = await createPersistedQuery(netlifyToken, payload)
   const newMetadata = await { docId: persistedDoc.id }
-  const result = await OneGraphClient.updateCLISessionMetadata(netlifyToken, siteId, oneGraphSessionId, newMetadata)
+  const result = await upsertMergeCLISessionMetadata({
+    netlifyGraphConfig,
+    netlifyToken,
+    siteId,
+    oneGraphSessionId,
+    newMetadata,
+    siteRoot,
+  })
 
   if (result.errors) {
     warn(`Unable to update session metadata with updated operations doc ${JSON.stringify(result.errors, null, 2)}`)
   }
 }
 
+const createCLISession = ({ metadata, netlifyToken, sessionName, siteId }) => {
+  const result = OneGraphClient.createCLISession(netlifyToken, siteId, sessionName, metadata)
+  return result
+}
+
 /**
  * Load the CLI session id from the local state
  * @param {StateConfig} state
@@ -322,7 +416,12 @@ const startOneGraphCLISession = async (input) => {
   if (!oneGraphSessionId) {
     const sessionName = generateSessionName()
     const sessionMetadata = {}
-    const oneGraphSession = await OneGraphClient.createCLISession(netlifyToken, site.id, sessionName, sessionMetadata)
+    const oneGraphSession = await createCLISession({
+      netlifyToken,
+      siteId: site.id,
+      sessionName,
+      metadata: sessionMetadata,
+    })
     state.set('oneGraphSessionId', oneGraphSession.id)
     oneGraphSessionId = state.get('oneGraphSessionId')
   }
@@ -337,10 +436,12 @@ const startOneGraphCLISession = async (input) => {
       regenerateFunctionsFileFromOperationsFile({ netlifyGraphConfig, schema })
       const newOperationsDoc = readGraphQLOperationsSourceFile(netlifyGraphConfig)
       await persistNewOperationsDocForSession({
+        netlifyGraphConfig,
         netlifyToken,
         oneGraphSessionId,
         operationsDoc: newOperationsDoc,
         siteId: site.id,
+        siteRoot: site.root,
       })
     },
     onAdd: async (filePath) => {
@@ -348,10 +449,12 @@ const startOneGraphCLISession = async (input) => {
       regenerateFunctionsFileFromOperationsFile({ netlifyGraphConfig, schema })
       const newOperationsDoc = readGraphQLOperationsSourceFile(netlifyGraphConfig)
       await persistNewOperationsDocForSession({
+        netlifyGraphConfig,
         netlifyToken,
         oneGraphSessionId,
         operationsDoc: newOperationsDoc,
         siteId: site.id,
+        siteRoot: site.root,
       })
     },
   })
@@ -393,7 +496,6 @@ const generateSessionName = () => {
 
 const OneGraphCliClient = {
   ackCLISessionEvents: OneGraphClient.ackCLISessionEvents,
-  createCLISession,
   createPersistedQuery,
   fetchCliSessionEvents: OneGraphClient.fetchCliSessionEvents,
   ensureAppForSite,
@@ -402,6 +504,7 @@ const OneGraphCliClient = {
 
 module.exports = {
   OneGraphCliClient,
+  createCLISession,
   extractFunctionsFromOperationDoc,
   handleCliSessionEvent,
   generateSessionName,
@@ -410,4 +513,5 @@ module.exports = {
   persistNewOperationsDocForSession,
   refetchAndGenerateFromOneGraph,
   startOneGraphCLISession,
+  upsertMergeCLISessionMetadata,
 }

package/src/lib/one-graph/cli-netlify-graph.js

@@ -3,7 +3,7 @@ const fs = require('fs')
 const path = require('path')
 const process = require('process')
 
-const { GraphQL, InternalConsole, NetlifyGraph } = require('netlify-onegraph-internal')
+const { GraphQL, GraphQLHelpers, InternalConsole, NetlifyGraph } = require('netlify-onegraph-internal')
 
 const { detectServerSettings, error, execa, getFunctionsDir, log, warn } = require('../../utils')
 
@@ -167,6 +167,8 @@ const getNetlifyGraphConfig = async ({ command, options, settings }) => {
     }
   }
 
+  const defaulFunctionsPath = ['netlify', 'functions']
+
   const siteRoot = [path.sep, ...filterRelativePathItems(site.root.split(path.sep))]
 
   const tsConfig = 'tsconfig.json'
@@ -178,7 +180,7 @@ const getNetlifyGraphConfig = async ({ command, options, settings }) => {
   const detectedFunctionsPathString = getFunctionsDir({ config, options })
   const detectedFunctionsPath = detectedFunctionsPathString
     ? [path.sep, ...detectedFunctionsPathString.split(path.sep)]
-    : null
+    : defaulFunctionsPath
   const baseConfig = { ...NetlifyGraph.defaultNetlifyGraphConfig, ...userSpecifiedConfig }
   const defaultFrameworkConfig = makeDefaultFrameworkConfig({ baseConfig, detectedFunctionsPath, siteRoot })
 
@@ -202,6 +204,10 @@ const getNetlifyGraphConfig = async ({ command, options, settings }) => {
     (userSpecifiedConfig.graphQLOperationsSourceFilename &&
       userSpecifiedConfig.graphQLOperationsSourceFilename.split(path.sep)) ||
     defaultFrameworkConfig.graphQLOperationsSourceFilename
+  const graphQLConfigJsonFilename =
+    (userSpecifiedConfig.graphQLConfigJsonFilename && userSpecifiedConfig.graphQLConfigJsonFilename.split(path.sep)) ||
+    defaultFrameworkConfig.graphQLConfigJsonFilename ||
+    baseConfig.graphQLConfigJsonFilename
   const graphQLSchemaFilename =
     (userSpecifiedConfig.graphQLSchemaFilename && userSpecifiedConfig.graphQLSchemaFilename.split(path.sep)) ||
     defaultFrameworkConfig.graphQLSchemaFilename
@@ -229,6 +235,7 @@ const getNetlifyGraphConfig = async ({ command, options, settings }) => {
     netlifyGraphTypeDefinitionsFilename,
     graphQLOperationsSourceFilename,
     graphQLSchemaFilename,
+    graphQLConfigJsonFilename,
     netlifyGraphRequirePath,
     framework,
     language,
@@ -473,7 +480,7 @@ const { buildSchema, parse } = GraphQL
 const getGraphEditUrlBySiteName = ({ oneGraphSessionId, siteName }) => {
   const host = process.env.NETLIFY_APP_HOST || 'app.netlify.com'
   // http because app.netlify.com will redirect to https, and localhost will still work for development
-  const url = `http://${host}/sites/${siteName}/graph/explorer?cliSessionId=${oneGraphSessionId}`
+  const url = `http://${host}/sites/app/${siteName}/graph/explorer/${oneGraphSessionId}`
 
   return url
 }
@@ -488,7 +495,7 @@ const getGraphEditUrlBySiteName = ({ oneGraphSessionId, siteName }) => {
 const getGraphEditUrlBySiteId = ({ oneGraphSessionId, siteId }) => {
   const host = process.env.NETLIFY_APP_HOST || 'app.netlify.com'
   // http because app.netlify.com will redirect to https, and localhost will still work for development
-  const url = `http://${host}/site-redirect/${siteId}/graph/explorer?cliSessionId=${oneGraphSessionId}`
+  const url = `http://${host}/site-redirect/${siteId}/graph/explorer/${oneGraphSessionId}`
 
   return url
 }
@@ -505,6 +512,7 @@ module.exports = {
   getGraphEditUrlBySiteId,
   getGraphEditUrlBySiteName,
   getNetlifyGraphConfig,
+  normalizeOperationsDoc: GraphQLHelpers.normalizeOperationsDoc,
   parse,
   readGraphQLOperationsSourceFile,
   readGraphQLSchemaFile,

package/src/utils/dev.js

@@ -194,12 +194,12 @@ const acquirePort = async ({ configuredPort, defaultPort, errorMessage }) => {
   return acquiredPort
 }
 
-// Generates an Authlify JWT with the following claims:
+// 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.
-const generateAuthlifyJWT = (netlifyToken, authlifyTokenId, siteId) => {
+const generateNetlifyGraphJWT = ({ authlifyTokenId, netlifyToken, siteId }) => {
   const claims = {
     netlify_token: netlifyToken,
     authlify_token_id: authlifyTokenId,
@@ -219,5 +219,5 @@ module.exports = {
   getSiteInformation,
   injectEnvVariables,
   acquirePort,
-  generateAuthlifyJWT,
+  generateNetlifyGraphJWT,
 }