netlify-cli 8.18.1 → 8.19.0

package/README.md

@@ -160,6 +160,9 @@ Manage netlify functions
 | Subcommand | description  |
 |:--------------------------- |:-----|
 | [`graph:edit`](/docs/commands/graph.md#graphedit) | Launch the browser to edit your local graph functions from Netlify  |
+| [`graph:handler`](/docs/commands/graph.md#graphhandler) | Generate a handler for a Graph operation given its name. See `graph:operations` for a list of operations.  |
+| [`graph:library`](/docs/commands/graph.md#graphlibrary) | Generate the Graph function library  |
+| [`graph:operations`](/docs/commands/graph.md#graphoperations) | List all of the locally available operations  |
 | [`graph:pull`](/docs/commands/graph.md#graphpull) | Pull down your local Netlify Graph schema, and process pending Graph edit events  |
 
 

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "netlify-cli",
-  "version": "8.18.1",
+  "version": "8.19.0",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "netlify-cli",
-      "version": "8.18.1",
+      "version": "8.19.0",
       "hasInstallScript": true,
       "license": "MIT",
       "dependencies": {
@@ -82,7 +82,7 @@
         "multiparty": "^4.2.1",
         "netlify": "^11.0.0",
         "netlify-headers-parser": "^6.0.1",
-        "netlify-onegraph-internal": "0.0.18",
+        "netlify-onegraph-internal": "0.0.28",
         "netlify-redirect-parser": "^13.0.2",
         "netlify-redirector": "^0.2.1",
         "node-fetch": "^2.6.0",
@@ -15762,9 +15762,9 @@
       }
     },
     "node_modules/netlify-onegraph-internal": {
-      "version": "0.0.18",
-      "resolved": "https://registry.npmjs.org/netlify-onegraph-internal/-/netlify-onegraph-internal-0.0.18.tgz",
-      "integrity": "sha512-dUODB7zQDj03gwXQZQPlxFAfB1NBAtAt0A/CvWkfieG0g3MuRFAT/TOQGWtFesN1HkRZbW7dnC3JR9S9jB66WQ==",
+      "version": "0.0.28",
+      "resolved": "https://registry.npmjs.org/netlify-onegraph-internal/-/netlify-onegraph-internal-0.0.28.tgz",
+      "integrity": "sha512-csKAJ43gcdOBk1UsdVAQcfsMobDPjxqqTEZzWZOhlxjQvOZQJHXtoqnbD0eLfYl7TqCQFz2+Y/bWILIrHzYTIQ==",
       "dependencies": {
         "graphql": "16.0.0",
         "node-fetch": "^2.6.0",
@@ -34723,9 +34723,9 @@
       }
     },
     "netlify-onegraph-internal": {
-      "version": "0.0.18",
-      "resolved": "https://registry.npmjs.org/netlify-onegraph-internal/-/netlify-onegraph-internal-0.0.18.tgz",
-      "integrity": "sha512-dUODB7zQDj03gwXQZQPlxFAfB1NBAtAt0A/CvWkfieG0g3MuRFAT/TOQGWtFesN1HkRZbW7dnC3JR9S9jB66WQ==",
+      "version": "0.0.28",
+      "resolved": "https://registry.npmjs.org/netlify-onegraph-internal/-/netlify-onegraph-internal-0.0.28.tgz",
+      "integrity": "sha512-csKAJ43gcdOBk1UsdVAQcfsMobDPjxqqTEZzWZOhlxjQvOZQJHXtoqnbD0eLfYl7TqCQFz2+Y/bWILIrHzYTIQ==",
       "requires": {
         "graphql": "16.0.0",
         "node-fetch": "^2.6.0",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "netlify-cli",
   "description": "Netlify command line tool",
-  "version": "8.18.1",
+  "version": "8.19.0",
   "author": "Netlify Inc.",
   "contributors": [
     "Mathias Biilmann <matt@netlify.com> (https://twitter.com/biilmann)",
@@ -43,6 +43,7 @@
     "url": "https://github.com/netlify/cli/issues"
   },
   "scripts": {
+    "snap": "ava --verbose -u",
     "prepare": "husky install node_modules/@netlify/eslint-config-node/.husky/",
     "start": "node ./bin/run",
     "test": "run-s format test:dev",
@@ -149,7 +150,7 @@
     "multiparty": "^4.2.1",
     "netlify": "^11.0.0",
     "netlify-headers-parser": "^6.0.1",
-    "netlify-onegraph-internal": "0.0.18",
+    "netlify-onegraph-internal": "0.0.28",
     "netlify-redirect-parser": "^13.0.2",
     "netlify-redirector": "^0.2.1",
     "node-fetch": "^2.6.0",

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

@@ -1,3 +1,4 @@
+// @ts-check
 const gitRepoInfo = require('git-repo-info')
 
 const { OneGraphCliClient, generateSessionName, loadCLISession } = require('../../lib/one-graph/cli-client')
@@ -15,7 +16,7 @@ const { createCLISession, createPersistedQuery, ensureAppForSite, updateCLISessi
 /**
  * Creates the `netlify graph:edit` command
  * @param {import('commander').OptionValues} options
- * @param {import('../base-command').BaseCommand} program
+ * @param {import('../base-command').BaseCommand} command
  * @returns
  */
 const graphEdit = async (options, command) => {
@@ -46,7 +47,7 @@ const graphEdit = async (options, command) => {
   let oneGraphSessionId = loadCLISession(state)
   if (!oneGraphSessionId) {
     const sessionName = generateSessionName()
-    const oneGraphSession = await createCLISession(netlifyToken, site.id, sessionName)
+    const oneGraphSession = await createCLISession(netlifyToken, site.id, sessionName, null)
     state.set('oneGraphSessionId', oneGraphSession.id)
     oneGraphSessionId = state.get('oneGraphSessionId')
   }

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

@@ -0,0 +1,53 @@
+// @ts-check
+const {
+  buildSchema,
+  generateHandlerByOperationName,
+  getNetlifyGraphConfig,
+  readGraphQLSchemaFile,
+} = require('../../lib/one-graph/cli-netlify-graph')
+const { error } = require('../../utils')
+
+/**
+ * Creates the `netlify graph:handler` command
+ * @param {string} operationName
+ * @param {import('commander').OptionValues} options
+ * @param {import('../base-command').BaseCommand} command
+ * @returns
+ */
+const graphHandler = async (operationName, options, command) => {
+  const netlifyGraphConfig = await getNetlifyGraphConfig({ command, options })
+
+  const schemaString = readGraphQLSchemaFile(netlifyGraphConfig)
+
+  let schema
+
+  try {
+    schema = buildSchema(schemaString)
+  } catch (buildSchemaError) {
+    error(`Error parsing schema: ${buildSchemaError}`)
+  }
+
+  if (!schema) {
+    error(`Failed to parse Netlify GraphQL schema`)
+  }
+
+  generateHandlerByOperationName(netlifyGraphConfig, schema, operationName, {})
+}
+
+/**
+ * Creates the `netlify graph:handler` command
+ * @param {import('../base-command').BaseCommand} program
+ * @returns
+ */
+const createGraphHandlerCommand = (program) =>
+  program
+    .command('graph:handler')
+    .argument('<name>', 'Operation name')
+    .description(
+      'Generate a handler for a Graph operation given its name. See `graph:operations` for a list of operations.',
+    )
+    .action(async (operationName, options, command) => {
+      await graphHandler(operationName, options, command)
+    })
+
+module.exports = { createGraphHandlerCommand }

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

@@ -0,0 +1,61 @@
+// @ts-check
+const {
+  buildSchema,
+  defaultExampleOperationsDoc,
+  extractFunctionsFromOperationDoc,
+  generateFunctionsFile,
+  getNetlifyGraphConfig,
+  parse,
+  readGraphQLOperationsSourceFile,
+  readGraphQLSchemaFile,
+} = require('../../lib/one-graph/cli-netlify-graph')
+const { error } = require('../../utils')
+
+/**
+ * Creates the `netlify graph:library` command
+ * @param {import('commander').OptionValues} options
+ * @param {import('../base-command').BaseCommand} command
+ * @returns
+ */
+const graphLibrary = async (options, command) => {
+  const netlifyGraphConfig = await getNetlifyGraphConfig({ command, options })
+
+  const schemaString = readGraphQLSchemaFile(netlifyGraphConfig)
+
+  let schema
+
+  try {
+    schema = buildSchema(schemaString)
+  } catch (buildSchemaError) {
+    error(`Error parsing schema: ${buildSchemaError}`)
+  }
+
+  if (!schema) {
+    error(`Failed to parse Netlify GraphQL schema`)
+  }
+
+  let currentOperationsDoc = readGraphQLOperationsSourceFile(netlifyGraphConfig)
+  if (currentOperationsDoc.trim().length === 0) {
+    currentOperationsDoc = defaultExampleOperationsDoc
+  }
+
+  const parsedDoc = parse(currentOperationsDoc)
+  const { fragments, functions } = extractFunctionsFromOperationDoc(parsedDoc)
+
+  generateFunctionsFile({ netlifyGraphConfig, schema, operationsDoc: currentOperationsDoc, functions, fragments })
+}
+
+/**
+ * Creates the `netlify graph:library` command
+ * @param {import('../base-command').BaseCommand} program
+ * @returns
+ */
+const createGraphLibraryCommand = (program) =>
+  program
+    .command('graph:library')
+    .description('Generate the Graph function library')
+    .action(async (options, command) => {
+      await graphLibrary(options, command)
+    })
+
+module.exports = { createGraphLibraryCommand }

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

@@ -0,0 +1,113 @@
+// @ts-check
+const { GraphQL } = require('netlify-onegraph-internal')
+
+const {
+  defaultExampleOperationsDoc,
+  extractFunctionsFromOperationDoc,
+  getNetlifyGraphConfig,
+  readGraphQLOperationsSourceFile,
+} = require('../../lib/one-graph/cli-netlify-graph')
+const { log } = require('../../utils')
+
+const { parse } = GraphQL
+
+/**
+ * Creates the `netlify graph:operations` command
+ * @param {import('commander').OptionValues} options
+ * @param {import('../base-command').BaseCommand} 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(parsedDoc)
+
+    const sorted = {
+      queries: [],
+      mutations: [],
+      subscriptions: [],
+      fragments: [],
+      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').BaseCommand} program
+ * @returns
+ */
+const createGraphOperationCommand = (program) =>
+  program
+    .command('graph:operations')
+    .description('List all of the locally available operations')
+    .action(async (options, command) => {
+      await graphOperations(options, command)
+    })
+
+module.exports = { createGraphOperationCommand }

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

@@ -1,3 +1,4 @@
+// @ts-check
 /* eslint-disable eslint-comments/disable-enable-pair */
 /* eslint-disable fp/no-loops */
 const {
@@ -12,7 +13,7 @@ const { chalk, error, warn } = require('../../utils')
 /**
  * Creates the `netlify graph:pull` command
  * @param {import('commander').OptionValues} options
- * @param {import('../base-command').BaseCommand} program
+ * @param {import('../base-command').BaseCommand} command
  * @returns
  */
 const graphPull = async (options, command) => {
@@ -60,7 +61,7 @@ const graphPull = async (options, command) => {
   })
 
   if (next.errors) {
-    error(`Failed to fetch Netlify Graph cli session events`, next.errors)
+    error(`Failed to fetch Netlify Graph cli session events: ${JSON.stringify(next.errors, null, 2)}`)
   }
 
   if (next.events) {

package/src/commands/graph/graph.js

@@ -1,5 +1,8 @@
 // @ts-check
 const { createGraphEditCommand } = require('./graph-edit')
+const { createGraphHandlerCommand } = require('./graph-handler')
+const { createGraphLibraryCommand } = require('./graph-library')
+const { createGraphOperationCommand } = require('./graph-operations')
 const { createGraphPullCommand } = require('./graph-pull')
 
 /**
@@ -18,6 +21,9 @@ const graph = (options, command) => {
  */
 const createGraphCommand = (program) => {
   createGraphEditCommand(program)
+  createGraphHandlerCommand(program)
+  createGraphLibraryCommand(program)
+  createGraphOperationCommand(program)
   createGraphPullCommand(program)
 
   return program

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

@@ -1,3 +1,4 @@
+// @ts-check
 /* eslint-disable eslint-comments/disable-enable-pair */
 /* eslint-disable fp/no-loops */
 const crypto = require('crypto')
@@ -8,12 +9,13 @@ const gitRepoInfo = require('git-repo-info')
 const { GraphQL, InternalConsole, OneGraphClient } = require('netlify-onegraph-internal')
 const { NetlifyGraph } = require('netlify-onegraph-internal')
 
-const { chalk, error, log, warn } = require('../../utils')
+// eslint-disable-next-line no-unused-vars
+const { StateConfig, chalk, error, log, warn } = require('../../utils')
 const { watchDebounced } = require('../functions/watcher')
 
 const {
   generateFunctionsFile,
-  generateHandler,
+  generateHandlerByOperationId,
   readGraphQLOperationsSourceFile,
   writeGraphQLOperationsSourceFile,
   writeGraphQLSchemaFile,
@@ -30,9 +32,11 @@ const internalConsole = {
   debug: console.debug,
 }
 
+/**
+ * Keep track of which document hashes we've received from the server so we can ignore events from the filesystem based on them
+ */
 const witnessedIncomingDocumentHashes = []
 
-// Keep track of which document hashes we've received from the server so we can ignore events from the filesystem based on them
 InternalConsole.registerConsole(internalConsole)
 
 /**
@@ -40,12 +44,12 @@ InternalConsole.registerConsole(internalConsole)
  * @param {object} input
  * @param {string} input.appId The app to query against, typically the siteId
  * @param {string} input.netlifyToken The (typically netlify) access token that is used for authentication, if any
- * @param {NetlifyGraphConfig} input.netlifyGraphConfig A standalone config object that contains all the information necessary for Netlify Graph to process events
+ * @param {NetlifyGraph.NetlifyGraphConfig} input.netlifyGraphConfig A standalone config object that contains all the information necessary for Netlify Graph to process events
  * @param {function} input.onClose A function to call when the polling loop is closed
  * @param {function} input.onError A function to call when an error occurs
  * @param {function} input.onEvents A function to call when CLI events are received and need to be processed
  * @param {string} input.sessionId The session id to monitor CLI events for
- * @param {state} input.state A function to call to set/get the current state of the local Netlify project
+ * @param {StateConfig} input.state A function to call to set/get the current state of the local Netlify project
  * @returns
  */
 const monitorCLISessionEvents = (input) => {
@@ -117,15 +121,16 @@ const monitorCLISessionEvents = (input) => {
 /**
  * Monitor the operations document for changes
  * @param {object} input
- * @param {NetlifyGraphConfig} input.netlifyGraphConfig A standalone config object that contains all the information necessary for Netlify Graph to process events
- * @param {function} input.onAdd A callback function to handle when the operations document is added
- * @param {function} input.onChange A callback function to handle when the operations document is changed
- * @param {function} input.onUnlink A callback function to handle when the operations document is unlinked
- * @returns {Promise<watcher>}
+ * @param {NetlifyGraph.NetlifyGraphConfig} input.netlifyGraphConfig A standalone config object that contains all the information necessary for Netlify Graph to process events
+ * @param {() => void} input.onAdd A callback function to handle when the operations document is added
+ * @param {() => void} input.onChange A callback function to handle when the operations document is changed
+ * @param {() => void=} input.onUnlink A callback function to handle when the operations document is unlinked
+ * @returns {Promise<any>}
  */
 const monitorOperationFile = async ({ netlifyGraphConfig, onAdd, onChange, onUnlink }) => {
   const filePath = path.resolve(...netlifyGraphConfig.graphQLOperationsSourceFilename)
   const newWatcher = await watchDebounced([filePath], {
+    depth: 1,
     onAdd,
     onChange,
     onUnlink,
@@ -139,8 +144,8 @@ const monitorOperationFile = async ({ netlifyGraphConfig, onAdd, onChange, onUnl
  * @param {object} input
  * @param {string} input.siteId The id of the site to query against
  * @param {string} input.netlifyToken The (typically netlify) access token that is used for authentication, if any
- * @param {NetlifyGraphConfig} input.netlifyGraphConfig A standalone config object that contains all the information necessary for Netlify Graph to process events
- * @param {state} input.state A function to call to set/get the current state of the local Netlify project
+ * @param {NetlifyGraph.NetlifyGraphConfig} input.netlifyGraphConfig A standalone config object that contains all the information necessary for Netlify Graph to process events
+ * @param {StateConfig} input.state A function to call to set/get the current state of the local Netlify project
  * @returns {Promise<void>}
  */
 const refetchAndGenerateFromOneGraph = async (input) => {
@@ -174,8 +179,8 @@ const refetchAndGenerateFromOneGraph = async (input) => {
 /**
  * Regenerate the function library based on the current operations document on disk
  * @param {object} input
- * @param {string} input.schema The GraphQL schema to use when generating code
- * @param {NetlifyGraphConfig} input.netlifyGraphConfig A standalone config object that contains all the information necessary for Netlify Graph to process events
+ * @param {GraphQL.GraphQLSchema} input.schema The GraphQL schema to use when generating code
+ * @param {NetlifyGraph.NetlifyGraphConfig} input.netlifyGraphConfig A standalone config object that contains all the information necessary for Netlify Graph to process events
  * @returns
  */
 const regenerateFunctionsFileFromOperationsFile = (input) => {
@@ -214,15 +219,15 @@ const quickHash = (input) => {
  * @param {string} input.siteId The site id to query against
  * @param {string} input.netlifyToken The (typically netlify) access token that is used for authentication, if any
  * @param {string} input.docId The GraphQL operations document id to fetch
- * @param {string} input.schema The GraphQL schema to use when generating code
- * @param {NetlifyGraphConfig} input.netlifyGraphConfig A standalone config object that contains all the information necessary for Netlify Graph to process events
+ * @param {GraphQL.GraphQLSchema} input.schema The GraphQL schema to use when generating code
+ * @param {NetlifyGraph.NetlifyGraphConfig} input.netlifyGraphConfig A standalone config object that contains all the information necessary for Netlify Graph to process events
  * @returns
  */
 const updateGraphQLOperationsFileFromPersistedDoc = async (input) => {
   const { docId, netlifyGraphConfig, netlifyToken, schema, siteId } = input
   const persistedDoc = await OneGraphClient.fetchPersistedQuery(netlifyToken, siteId, docId)
   if (!persistedDoc) {
-    warn('No persisted doc found for:', docId)
+    warn(`No persisted doc found for: ${docId}`)
     return
   }
 
@@ -249,7 +254,11 @@ const handleCliSessionEvent = async ({ event, netlifyGraphConfig, netlifyToken,
       await handleCliSessionEvent({ netlifyToken, event: payload, netlifyGraphConfig, schema, siteId })
       break
     case 'OneGraphNetlifyCliSessionGenerateHandlerEvent':
-      await generateHandler(netlifyGraphConfig, schema, payload.operationId, payload)
+      if (!payload.operationId || !payload.operationId.id) {
+        warn(`No operation id found in payload, ${JSON.stringify(payload, null, 2)}`)
+        return
+      }
+      generateHandlerByOperationId(netlifyGraphConfig, schema, payload.operationId.id, payload)
       break
     case 'OneGraphNetlifyCliSessionPersistedLibraryUpdatedEvent':
       await updateGraphQLOperationsFileFromPersistedDoc({
@@ -261,7 +270,13 @@ const handleCliSessionEvent = async ({ event, netlifyGraphConfig, netlifyToken,
       })
       break
     default: {
-      warn(`Unrecognized event received, you may need to upgrade your CLI version`, __typename, payload)
+      warn(
+        `Unrecognized event received, you may need to upgrade your CLI version: ${__typename}: ${JSON.stringify(
+          payload,
+          null,
+          2,
+        )}`,
+      )
       break
     }
   }
@@ -281,13 +296,13 @@ const persistNewOperationsDocForSession = async ({ netlifyToken, oneGraphSession
   const result = await OneGraphClient.updateCLISessionMetadata(netlifyToken, siteId, oneGraphSessionId, newMetadata)
 
   if (result.errors) {
-    warn('Unable to update session metadata with updated operations doc', result.errors)
+    warn(`Unable to update session metadata with updated operations doc ${JSON.stringify(result.errors, null, 2)}`)
   }
 }
 
 /**
  * Load the CLI session id from the local state
- * @param {state} state
+ * @param {StateConfig} state
  * @returns
  */
 const loadCLISession = (state) => state.get('oneGraphSessionId')
@@ -296,9 +311,9 @@ const loadCLISession = (state) => state.get('oneGraphSessionId')
  * Idemponentially save the CLI session id to the local state and start monitoring for CLI events, upstream schema changes, and local operation file changes
  * @param {object} input
  * @param {string} input.netlifyToken The (typically netlify) access token that is used for authentication, if any
- * @param {NetlifyGraphConfig} input.netlifyGraphConfig A standalone config object that contains all the information necessary for Netlify Graph to process events
- * @param {state} input.state A function to call to set/get the current state of the local Netlify project
- * @param {site} input.site The site object
+ * @param {NetlifyGraph.NetlifyGraphConfig} input.netlifyGraphConfig A standalone config object that contains all the information necessary for Netlify Graph to process events
+ * @param {StateConfig} input.state A function to call to set/get the current state of the local Netlify project
+ * @param {any} input.site The site object
  */
 const startOneGraphCLISession = async (input) => {
   const { netlifyGraphConfig, netlifyToken, site, state } = input
@@ -387,6 +402,7 @@ const OneGraphCliClient = {
 
 module.exports = {
   OneGraphCliClient,
+  extractFunctionsFromOperationDoc,
   handleCliSessionEvent,
   generateSessionName,
   loadCLISession,

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

@@ -1,3 +1,4 @@
+// @ts-check
 const fs = require('fs')
 const path = require('path')
 const process = require('process')
@@ -17,6 +18,8 @@ const internalConsole = {
 
 InternalConsole.registerConsole(internalConsole)
 
+const { extractFunctionsFromOperationDoc } = NetlifyGraph
+
 /**
  * Remove any relative path components from the given path
  * @param {string[]} items Filesystem path items to filter
@@ -27,10 +30,11 @@ const filterRelativePathItems = (items) => items.filter((part) => part !== '')
 /**
  * Return the default Netlify Graph configuration for a generic site
  * @param {object} context
+ * @param {object} context.baseConfig
  * @param {string[]} context.detectedFunctionsPath
  * @param {string[]} context.siteRoot
  */
-const makeDefaultNetlifGraphConfig = ({ baseConfig, detectedFunctionsPath }) => {
+const makeDefaultNetlifyGraphConfig = ({ baseConfig, detectedFunctionsPath }) => {
   const functionsPath = filterRelativePathItems([...detectedFunctionsPath])
   const webhookBasePath = '/.netlify/functions'
   const netlifyGraphPath = [...functionsPath, 'netlifyGraph']
@@ -57,10 +61,11 @@ const makeDefaultNetlifGraphConfig = ({ baseConfig, detectedFunctionsPath }) =>
 /**
  * Return the default Netlify Graph configuration for a Nextjs site
  * @param {object} context
+ * @param {object} context.baseConfig
  * @param {string[]} context.detectedFunctionsPath
  * @param {string[]} context.siteRoot
  */
-const makeDefaultNextJsNetlifGraphConfig = ({ baseConfig, siteRoot }) => {
+const makeDefaultNextJsNetlifyGraphConfig = ({ baseConfig, siteRoot }) => {
   const functionsPath = filterRelativePathItems([...siteRoot, 'pages', 'api'])
   const webhookBasePath = '/api'
   const netlifyGraphPath = filterRelativePathItems([...siteRoot, 'lib', 'netlifyGraph'])
@@ -87,10 +92,11 @@ const makeDefaultNextJsNetlifGraphConfig = ({ baseConfig, siteRoot }) => {
 /**
  * Return the default Netlify Graph configuration for a Remix site
  * @param {object} context
+ * @param {object} context.baseConfig
  * @param {string[]} context.detectedFunctionsPath
  * @param {string[]} context.siteRoot
  */
-const makeDefaultRemixNetlifGraphConfig = ({ baseConfig, detectedFunctionsPath, siteRoot }) => {
+const makeDefaultRemixNetlifyGraphConfig = ({ baseConfig, detectedFunctionsPath, siteRoot }) => {
   const functionsPath = filterRelativePathItems([...detectedFunctionsPath])
   const webhookBasePath = '/webhooks'
   const netlifyGraphPath = filterRelativePathItems([
@@ -118,22 +124,25 @@ const makeDefaultRemixNetlifGraphConfig = ({ baseConfig, detectedFunctionsPath,
 }
 
 const defaultFrameworkLookup = {
-  'Next.js': makeDefaultNextJsNetlifGraphConfig,
-  Remix: makeDefaultRemixNetlifGraphConfig,
-  default: makeDefaultNetlifGraphConfig,
+  'Next.js': makeDefaultNextJsNetlifyGraphConfig,
+  Remix: makeDefaultRemixNetlifyGraphConfig,
+  default: makeDefaultNetlifyGraphConfig,
 }
 
 /**
  * Return a full NetlifyGraph config with any defaults overridden by netlify.toml
- * @param {import('../base-command').BaseCommand} command
- * @return {NetlifyGraphConfig} NetlifyGraphConfig
+ * @param {object} input
+ * @param {import('../../commands/base-command').BaseCommand} input.command
+ * @param {import('commander').OptionValues} input.options
+ * @param {Partial<import('../../utils/types').ServerSettings>=} input.settings
+ * @return {Promise<NetlifyGraph.NetlifyGraphConfig>} NetlifyGraphConfig
  */
 const getNetlifyGraphConfig = async ({ command, options, settings }) => {
   const { config, site } = command.netlify
   config.dev = { ...config.dev }
   config.build = { ...config.build }
   const userSpecifiedConfig = (config && config.graph) || {}
-  /** @type {import('./types').DevConfig} */
+  /** @type {import('../../commands/dev/types').DevConfig} */
   const devConfig = {
     framework: '#auto',
     ...(config.functionsDirectory && { functions: config.functionsDirectory }),
@@ -148,7 +157,13 @@ const getNetlifyGraphConfig = async ({ command, options, settings }) => {
       settings = await detectServerSettings(devConfig, options, site.root)
     } catch (detectServerSettingsError) {
       settings = {}
-      warn('Error while auto-detecting project settings, Netlify Graph encounter problems', detectServerSettingsError)
+      warn(
+        `Error while auto-detecting project settings, Netlify Graph encounter problems: ${JSON.stringify(
+          detectServerSettingsError,
+          null,
+          2,
+        )}`,
+      )
     }
   }
 
@@ -167,9 +182,11 @@ const getNetlifyGraphConfig = async ({ command, options, settings }) => {
   const baseConfig = { ...NetlifyGraph.defaultNetlifyGraphConfig, ...userSpecifiedConfig }
   const defaultFrameworkConfig = makeDefaultFrameworkConfig({ baseConfig, detectedFunctionsPath, siteRoot })
 
+  const userSpecifiedFunctionPath =
+    userSpecifiedConfig.functionsPath && userSpecifiedConfig.functionsPath.split(path.sep)
+
   const functionsPath =
-    (userSpecifiedConfig.functionsPath && userSpecifiedConfig.functionsPath.split(path.sep)) ||
-    defaultFrameworkConfig.functionsPath
+    (userSpecifiedFunctionPath && [...siteRoot, ...userSpecifiedFunctionPath]) || defaultFrameworkConfig.functionsPath
   const netlifyGraphPath =
     (userSpecifiedConfig.netlifyGraphPath && userSpecifiedConfig.netlifyGraphPath.split(path.sep)) ||
     defaultFrameworkConfig.netlifyGraphPath
@@ -225,7 +242,7 @@ const getNetlifyGraphConfig = async ({ command, options, settings }) => {
 
 /**
  * Given a NetlifyGraphConfig, ensure that the netlifyGraphPath exists
- * @param {NetlifyGraphConfig} netlifyGraphConfig
+ * @param {NetlifyGraph.NetlifyGraphConfig} netlifyGraphConfig
  */
 const ensureNetlifyGraphPath = (netlifyGraphConfig) => {
   const fullPath = path.resolve(...netlifyGraphConfig.netlifyGraphPath)
@@ -234,7 +251,7 @@ const ensureNetlifyGraphPath = (netlifyGraphConfig) => {
 
 /**
  * Given a NetlifyGraphConfig, ensure that the functionsPath exists
- * @param {NetlifyGraphConfig} netlifyGraphConfig
+ * @param {NetlifyGraph.NetlifyGraphConfig} netlifyGraphConfig
  */
 const ensureFunctionsPath = (netlifyGraphConfig) => {
   const fullPath = path.resolve(...netlifyGraphConfig.functionsPath)
@@ -248,9 +265,8 @@ const runPrettier = async (filePath) => {
     return
   }
 
-  const command = `prettier --write ${filePath}`
   try {
-    const commandProcess = execa.command(command, {
+    const commandProcess = execa('prettier', ['--write', filePath], {
       preferLocal: true,
       // windowsHide needs to be false for child process to terminate properly on Windows
       windowsHide: false,
@@ -269,11 +285,11 @@ const runPrettier = async (filePath) => {
 /**
  * Generate a library file with type definitions for a given NetlifyGraphConfig, operationsDoc, and schema, writing them to the filesystem
  * @param {object} context
- * @param {NetlifyGraphConfig} context.netlifyGraphConfig
- * @param {GraphQLSchema} context.schema The schema to use when generating the functions and their types
+ * @param {NetlifyGraph.NetlifyGraphConfig} context.netlifyGraphConfig
+ * @param {GraphQL.GraphQLSchema} context.schema The schema to use when generating the functions and their types
  * @param {string} context.operationsDoc The GraphQL operations doc to use when generating the functions
- * @param {NetlifyGraph.ParsedFunction} context.functions The parsed queries with metadata to use when generating library functions
- * @param {NetlifyGraph.ParsedFragment} context.fragments The parsed queries with metadata to use when generating library functions
+ * @param {Record<string, NetlifyGraph.ExtractedFunction>} context.functions The parsed queries with metadata to use when generating library functions
+ * @param {Record<string, NetlifyGraph.ExtractedFragment>} context.fragments The parsed queries with metadata to use when generating library functions
  * @returns {void} Void, effectfully writes the generated library to the filesystem
  */
 const generateFunctionsFile = ({ fragments, functions, netlifyGraphConfig, operationsDoc, schema }) => {
@@ -298,7 +314,7 @@ const generateFunctionsFile = ({ fragments, functions, netlifyGraphConfig, opera
 
 /**
  * Using the given NetlifyGraphConfig, read the GraphQL operations file and return the _unparsed_ GraphQL operations doc
- * @param {NetlifyGraphConfig} netlifyGraphConfig
+ * @param {NetlifyGraph.NetlifyGraphConfig} netlifyGraphConfig
  * @returns {string} GraphQL operations doc
  */
 const readGraphQLOperationsSourceFile = (netlifyGraphConfig) => {
@@ -317,11 +333,11 @@ const readGraphQLOperationsSourceFile = (netlifyGraphConfig) => {
 
 /**
  * Write an operations doc to the filesystem using the given NetlifyGraphConfig
- * @param {NetlifyGraphConfig} netlifyGraphConfig
- * @param {string} operationsDoc The GraphQL operations doc to write
+ * @param {NetlifyGraph.NetlifyGraphConfig} netlifyGraphConfig
+ * @param {string} operationsDocString The GraphQL operations doc to write
  */
-const writeGraphQLOperationsSourceFile = (netlifyGraphConfig, operationDocString) => {
-  const graphqlSource = operationDocString
+const writeGraphQLOperationsSourceFile = (netlifyGraphConfig, operationsDocString) => {
+  const graphqlSource = operationsDocString
 
   ensureNetlifyGraphPath(netlifyGraphConfig)
   fs.writeFileSync(path.resolve(...netlifyGraphConfig.graphQLOperationsSourceFilename), graphqlSource, 'utf8')
@@ -329,8 +345,8 @@ const writeGraphQLOperationsSourceFile = (netlifyGraphConfig, operationDocString
 
 /**
  * Write a GraphQL Schema printed in SDL format to the filesystem using the given NetlifyGraphConfig
- * @param {NetlifyGraphConfig} netlifyGraphConfig
- * @param {GraphQLSchema} schema The GraphQL schema to print and write to the filesystem
+ * @param {NetlifyGraph.NetlifyGraphConfig} netlifyGraphConfig
+ * @param {GraphQL.GraphQLSchema} schema The GraphQL schema to print and write to the filesystem
  */
 const writeGraphQLSchemaFile = (netlifyGraphConfig, schema) => {
   const graphqlSource = printSchema(schema)
@@ -341,7 +357,7 @@ const writeGraphQLSchemaFile = (netlifyGraphConfig, schema) => {
 
 /**
  * Using the given NetlifyGraphConfig, read the GraphQL schema file and return it _unparsed_
- * @param {NetlifyGraphConfig} netlifyGraphConfig
+ * @param {NetlifyGraph.NetlifyGraphConfig} netlifyGraphConfig
  * @returns {string} GraphQL schema
  */
 const readGraphQLSchemaFile = (netlifyGraphConfig) => {
@@ -351,13 +367,13 @@ const readGraphQLSchemaFile = (netlifyGraphConfig) => {
 
 /**
  * Given a NetlifyGraphConfig, read the appropriate files and write a handler for the given operationId to the filesystem
- * @param {NetlifyGraphConfig} netlifyGraphConfig
- * @param {GraphQLSchema} schema The GraphQL schema to use when generating the handler
+ * @param {NetlifyGraph.NetlifyGraphConfig} netlifyGraphConfig
+ * @param {GraphQL.GraphQLSchema} schema The GraphQL schema to use when generating the handler
  * @param {string} operationId The operationId to use when generating the handler
  * @param {object} handlerOptions The options to use when generating the handler
  * @returns
  */
-const generateHandler = (netlifyGraphConfig, schema, operationId, handlerOptions) => {
+const generateHandlerByOperationId = (netlifyGraphConfig, schema, operationId, handlerOptions) => {
   let currentOperationsDoc = readGraphQLOperationsSourceFile(netlifyGraphConfig)
   if (currentOperationsDoc.trim().length === 0) {
     currentOperationsDoc = NetlifyGraph.defaultExampleOperationsDoc
@@ -415,6 +431,35 @@ const generateHandler = (netlifyGraphConfig, schema, operationId, handlerOptions
   })
 }
 
+/**
+ * Given a NetlifyGraphConfig, read the appropriate files and write a handler for the given operationId to the filesystem
+ * @param {NetlifyGraph.NetlifyGraphConfig} netlifyGraphConfig
+ * @param {GraphQL.GraphQLSchema} schema The GraphQL schema to use when generating the handler
+ * @param {string} operationName The name of the operation to use when generating the handler
+ * @param {object} handlerOptions The options to use when generating the handler
+ * @returns
+ */
+const generateHandlerByOperationName = (netlifyGraphConfig, schema, operationName, handlerOptions) => {
+  let currentOperationsDoc = readGraphQLOperationsSourceFile(netlifyGraphConfig)
+  if (currentOperationsDoc.trim().length === 0) {
+    currentOperationsDoc = NetlifyGraph.defaultExampleOperationsDoc
+  }
+
+  const parsedDoc = parse(currentOperationsDoc)
+  const { functions } = extractFunctionsFromOperationDoc(parsedDoc)
+
+  const operation = Object.values(functions).find(
+    (potentialOperation) => potentialOperation.operationName === operationName,
+  )
+
+  if (!operation) {
+    warn(`No operation named ${operationName} was found in the operations doc`)
+    return
+  }
+
+  generateHandlerByOperationId(netlifyGraphConfig, schema, operation.id, handlerOptions)
+}
+
 // Export the minimal set of functions that are required for Netlify Graph
 const { buildSchema, parse } = GraphQL
 
@@ -455,13 +500,15 @@ module.exports = {
   generateFunctionsSource: NetlifyGraph.generateFunctionsSource,
   generateFunctionsFile,
   generateHandlerSource: NetlifyGraph.generateHandlerSource,
-  generateHandler,
+  generateHandlerByOperationId,
+  generateHandlerByOperationName,
   getGraphEditUrlBySiteId,
   getGraphEditUrlBySiteName,
   getNetlifyGraphConfig,
   parse,
   readGraphQLOperationsSourceFile,
   readGraphQLSchemaFile,
+  runPrettier,
   writeGraphQLOperationsSourceFile,
   writeGraphQLSchemaFile,
 }

package/src/utils/command-helpers.js

@@ -47,8 +47,6 @@ const USER_AGENT = `${name}/${version} ${platform}-${arch} node-${process.versio
 /** A list of base command flags that needs to be sorted down on documentation and on help pages */
 const BASE_FLAGS = new Set(['--debug', '--httpProxy', '--httpProxyCertificateFilename'])
 
-const { NETLIFY_AUTH_TOKEN } = process.env
-
 // eslint-disable-next-line no-magic-numbers
 const NETLIFY_CYAN = chalk.rgb(40, 180, 170)
 
@@ -121,6 +119,7 @@ const getToken = async (tokenFromOptions) => {
     return [tokenFromOptions, 'flag']
   }
   // 2. then Check ENV var
+  const { NETLIFY_AUTH_TOKEN } = process.env
   if (NETLIFY_AUTH_TOKEN && NETLIFY_AUTH_TOKEN !== 'null') {
     return [NETLIFY_AUTH_TOKEN, 'env']
   }