netlify-cli 8.17.4 → 8.19.1

package/src/commands/sites/sites-create.js

@@ -13,6 +13,49 @@ const { link } = require('../link')
 
 const SITE_NAME_SUGGESTION_SUFFIX_LENGTH = 5
 
+const getSiteNameInput = async (name, user, api) => {
+  let siteSuggestion
+  if (!user) user = await api.getCurrentUser()
+
+  if (!name) {
+    let { slug } = user
+    let suffix = ''
+
+    // If the user doesn't have a slug, we'll compute one. Because `full_name` is not guaranteed to be unique, we
+    // append a short randomly-generated ID to reduce the likelihood of a conflict.
+    if (!slug) {
+      slug = slugify(user.full_name || user.email)
+      suffix = `-${uuidv4().slice(0, SITE_NAME_SUGGESTION_SUFFIX_LENGTH)}`
+    }
+
+    const suggestions = [
+      `super-cool-site-by-${slug}${suffix}`,
+      `the-awesome-${slug}-site${suffix}`,
+      `${slug}-makes-great-sites${suffix}`,
+      `netlify-thinks-${slug}-is-great${suffix}`,
+      `the-great-${slug}-site${suffix}`,
+      `isnt-${slug}-awesome${suffix}`,
+    ]
+    siteSuggestion = sample(suggestions)
+
+    console.log(
+      `Choose a unique site name (e.g. ${siteSuggestion}.netlify.app) or leave it blank for a random name. You can update the site name later.`,
+    )
+    const { name: nameInput } = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'name',
+        message: 'Site name (optional):',
+        filter: (val) => (val === '' ? undefined : val),
+        validate: (input) => /^[a-zA-Z\d-]+$/.test(input) || 'Only alphanumeric characters and hyphens are allowed',
+      },
+    ])
+    name = nameInput
+  }
+
+  return { name, siteSuggestion }
+}
+
 /**
  * The sites:create command
  * @param {import('commander').OptionValues} options
@@ -47,47 +90,11 @@ const sitesCreate = async (options, command) => {
 
   // Allow the user to reenter site name if selected one isn't available
   const inputSiteName = async (name) => {
-    if (!user) user = await api.getCurrentUser()
-
-    if (!name) {
-      let { slug } = user
-      let suffix = ''
-
-      // If the user doesn't have a slug, we'll compute one. Because `full_name` is not guaranteed to be unique, we
-      // append a short randomly-generated ID to reduce the likelihood of a conflict.
-      if (!slug) {
-        slug = slugify(user.full_name || user.email)
-        suffix = `-${uuidv4().slice(0, SITE_NAME_SUGGESTION_SUFFIX_LENGTH)}`
-      }
-
-      const suggestions = [
-        `super-cool-site-by-${slug}${suffix}`,
-        `the-awesome-${slug}-site${suffix}`,
-        `${slug}-makes-great-sites${suffix}`,
-        `netlify-thinks-${slug}-is-great${suffix}`,
-        `the-great-${slug}-site${suffix}`,
-        `isnt-${slug}-awesome${suffix}`,
-      ]
-      const siteSuggestion = sample(suggestions)
-
-      console.log(
-        `Choose a unique site name (e.g. ${siteSuggestion}.netlify.app) or leave it blank for a random name. You can update the site name later.`,
-      )
-      const { name: nameInput } = await inquirer.prompt([
-        {
-          type: 'input',
-          name: 'name',
-          message: 'Site name (optional):',
-          filter: (val) => (val === '' ? undefined : val),
-          validate: (input) => /^[a-zA-Z\d-]+$/.test(input) || 'Only alphanumeric characters and hyphens are allowed',
-        },
-      ])
-      name = nameInput
-    }
+    const { name: siteName } = await getSiteNameInput(name, user, api)
 
     const body = {}
-    if (typeof name === 'string') {
-      body.name = name.trim()
+    if (typeof siteName === 'string') {
+      body.name = siteName.trim()
     }
     try {
       site = await api.createSiteInTeam({
@@ -96,7 +103,7 @@ const sitesCreate = async (options, command) => {
       })
     } catch (error_) {
       if (error_.status === 422) {
-        warn(`${name}.netlify.app already exists. Please try a different slug.`)
+        warn(`${siteName}.netlify.app already exists. Please try a different slug.`)
         await inputSiteName()
       } else {
         error(`createSiteInTeam error: ${error_.status}: ${error_.message}`)
@@ -191,4 +198,4 @@ Create a blank site that isn't associated with any git remote. Will link the sit
     )
     .action(sitesCreate)
 
-module.exports = { createSitesCreateCommand, sitesCreate }
+module.exports = { createSitesCreateCommand, sitesCreate, getSiteNameInput }

package/src/commands/sites/sites.js

@@ -1,5 +1,6 @@
 // @ts-check
 const { createSitesCreateCommand } = require('./sites-create')
+const { createSitesFromTemplateCommand } = require('./sites-create-template')
 const { createSitesDeleteCommand } = require('./sites-delete')
 const { createSitesListCommand } = require('./sites-list')
 
@@ -19,6 +20,7 @@ const sites = (options, command) => {
  */
 const createSitesCommand = (program) => {
   createSitesCreateCommand(program)
+  createSitesFromTemplateCommand(program)
   createSitesListCommand(program)
   createSitesDeleteCommand(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']
   }

package/src/utils/sites/utils.js

@@ -0,0 +1,30 @@
+const fetch = require('node-fetch')
+
+const getTemplatesFromGitHub = async (token) => {
+  const templates = await fetch(`https://api.github.com/orgs/netlify-templates/repos`, {
+    method: 'GET',
+    headers: {
+      Authorization: `token ${token}`,
+    },
+  })
+  const allTemplates = await templates.json()
+
+  return allTemplates
+}
+
+const createRepo = async (templateUrl, ghToken, siteName) => {
+  const resp = await fetch(`https://api.github.com/repos/${templateUrl.templateName}/generate`, {
+    method: 'POST',
+    headers: {
+      Authorization: `token ${ghToken}`,
+    },
+    body: JSON.stringify({
+      name: siteName,
+    }),
+  })
+
+  const data = await resp.json()
+  return data
+}
+
+module.exports = { getTemplatesFromGitHub, createRepo }