netlify-cli 9.3.0 → 9.4.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "netlify-cli",
   "description": "Netlify command line tool",
-  "version": "9.3.0",
+  "version": "9.4.0",
   "author": "Netlify Inc.",
   "contributors": [
     "Abraham Schilling <AbrahamSchilling@gmail.com> (https://gitlab.com/n4bb12)",
@@ -198,8 +198,8 @@
     "prettier": "--ignore-path .gitignore --loglevel=warn \"{src,tools,scripts,site,tests,.github}/**/*.{mjs,cjs,js,md,yml,json,html}\" \"*.{mjs,cjs,js,yml,json,html}\" \".*.{mjs,cjs,js,yml,json,html}\" \"!CHANGELOG.md\" \"!npm-shrinkwrap.json\" \"!site/package-lock.json\" \"!.github/**/*.md\""
   },
   "dependencies": {
-    "@netlify/build": "^26.2.6",
-    "@netlify/config": "^17.0.7",
+    "@netlify/build": "^26.3.0",
+    "@netlify/config": "^17.0.8",
     "@netlify/framework-info": "^9.0.0",
     "@netlify/local-functions-proxy": "^1.1.1",
     "@netlify/plugin-edge-handlers": "^3.0.6",

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

@@ -1,9 +1,10 @@
 // @ts-check
 const fs = require('fs')
 const path = require('path')
+const process = require('process')
 
 const { getNetlifyGraphConfig } = require('../../lib/one-graph/cli-netlify-graph')
-const { NETLIFYDEVERR, chalk, error } = require('../../utils')
+const { NETLIFYDEVERR, chalk, error, log } = require('../../utils')
 
 /**
  * Creates the `netlify graph:config:write` command
@@ -33,8 +34,10 @@ const graphConfigWrite = async (options, command) => {
   }
 
   const filePath = path.resolve(...netlifyGraphConfig.graphQLConfigJsonFilename)
-
   fs.writeFileSync(filePath, JSON.stringify(graphQLConfig, null, 2))
+
+  const relativePath = path.relative(process.cwd(), filePath)
+  log(`Wrote ${chalk.cyan(relativePath)}`)
 }
 
 /**

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

@@ -14,7 +14,7 @@ const {
   getNetlifyGraphConfig,
   readGraphQLOperationsSourceFile,
 } = require('../../lib/one-graph/cli-netlify-graph')
-const { NETLIFYDEVERR, chalk, error } = require('../../utils')
+const { NETLIFYDEVERR, chalk, error, log } = require('../../utils')
 const { openBrowser } = require('../../utils/open-browser')
 
 const { createPersistedQuery, ensureAppForSite } = OneGraphCliClient
@@ -77,6 +77,7 @@ const graphEdit = async (options, command) => {
 
   const graphEditUrl = getGraphEditUrlBySiteId({ siteId, oneGraphSessionId })
 
+  log(`Opening graph:edit session at ${chalk.cyan(graphEditUrl)}`)
   await openBrowser({ url: graphEditUrl })
 }
 

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

@@ -5,7 +5,7 @@ const {
   getNetlifyGraphConfig,
   readGraphQLSchemaFile,
 } = require('../../lib/one-graph/cli-netlify-graph')
-const { error } = require('../../utils')
+const { error, log } = require('../../utils')
 
 /**
  * Creates the `netlify graph:handler` command
@@ -31,7 +31,7 @@ const graphHandler = async (operationName, options, command) => {
     error(`Failed to parse Netlify GraphQL schema`)
   }
 
-  generateHandlerByOperationName(netlifyGraphConfig, schema, operationName, {})
+  generateHandlerByOperationName({ logger: log, netlifyGraphConfig, schema, operationName, handlerOptions: {} })
 }
 
 /**

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

@@ -9,7 +9,7 @@ const {
   readGraphQLOperationsSourceFile,
   readGraphQLSchemaFile,
 } = require('../../lib/one-graph/cli-netlify-graph')
-const { error } = require('../../utils')
+const { error, log } = require('../../utils')
 
 /**
  * Creates the `netlify graph:library` command
@@ -42,7 +42,14 @@ const graphLibrary = async (options, command) => {
   const parsedDoc = parse(currentOperationsDoc)
   const { fragments, functions } = extractFunctionsFromOperationDoc(parsedDoc)
 
-  generateFunctionsFile({ netlifyGraphConfig, schema, operationsDoc: currentOperationsDoc, functions, fragments })
+  generateFunctionsFile({
+    logger: log,
+    netlifyGraphConfig,
+    schema,
+    operationsDoc: currentOperationsDoc,
+    functions,
+    fragments,
+  })
 }
 
 /**

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

@@ -8,7 +8,7 @@ const {
   refetchAndGenerateFromOneGraph,
 } = require('../../lib/one-graph/cli-client')
 const { buildSchema, getNetlifyGraphConfig, readGraphQLSchemaFile } = require('../../lib/one-graph/cli-netlify-graph')
-const { chalk, error, warn } = require('../../utils')
+const { chalk, error, log, warn } = require('../../utils')
 
 /**
  * Creates the `netlify graph:pull` command
@@ -31,12 +31,14 @@ const graphPull = async (options, command) => {
   const netlifyToken = await command.authenticate()
   const siteId = site.id
 
-  await refetchAndGenerateFromOneGraph({ netlifyGraphConfig, netlifyToken, state, siteId })
+  await refetchAndGenerateFromOneGraph({ logger: log, netlifyGraphConfig, netlifyToken, state, siteId })
 
   const oneGraphSessionId = loadCLISession(state)
 
   if (!oneGraphSessionId) {
-    warn('No local Netlify Graph session found, skipping command queue drain')
+    warn(
+      'No local Netlify Graph session found, skipping command queue drain. Create a new session by running `netlify graph:edit`.',
+    )
     return
   }
 

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

@@ -10,7 +10,7 @@ const { GraphQL, InternalConsole, OneGraphClient } = require('netlify-onegraph-i
 const { NetlifyGraph } = require('netlify-onegraph-internal')
 
 // eslint-disable-next-line no-unused-vars
-const { StateConfig, chalk, error, log, warn } = require('../../utils')
+const { StateConfig, USER_AGENT, chalk, error, log, warn } = require('../../utils')
 const { watchDebounced } = require('../functions/watcher')
 
 const {
@@ -147,10 +147,11 @@ const monitorOperationFile = async ({ netlifyGraphConfig, onAdd, onChange, onUnl
  * @param {string} input.netlifyToken The (typically netlify) access token that is used for authentication, if any
  * @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 {(message: string) => void=} input.logger A function that if provided will be used to log messages
  * @returns {Promise<void>}
  */
 const refetchAndGenerateFromOneGraph = async (input) => {
-  const { netlifyGraphConfig, netlifyToken, siteId, state } = input
+  const { logger, netlifyGraphConfig, netlifyToken, siteId, state } = input
   await OneGraphClient.ensureAppForSite(netlifyToken, siteId)
 
   const enabledServicesInfo = await OneGraphClient.fetchEnabledServices(netlifyToken, siteId)
@@ -162,6 +163,7 @@ const refetchAndGenerateFromOneGraph = async (input) => {
   const enabledServices = enabledServicesInfo
     .map((service) => service.service)
     .sort((aString, bString) => aString.localeCompare(bString))
+
   const schema = await OneGraphClient.fetchOneGraphSchema(siteId, enabledServices)
 
   let currentOperationsDoc = readGraphQLOperationsSourceFile(netlifyGraphConfig)
@@ -172,8 +174,15 @@ const refetchAndGenerateFromOneGraph = async (input) => {
   const parsedDoc = parse(currentOperationsDoc)
   const { fragments, functions } = extractFunctionsFromOperationDoc(parsedDoc)
 
-  generateFunctionsFile({ netlifyGraphConfig, schema, operationsDoc: currentOperationsDoc, functions, fragments })
-  writeGraphQLSchemaFile(netlifyGraphConfig, schema)
+  generateFunctionsFile({
+    logger,
+    netlifyGraphConfig,
+    schema,
+    operationsDoc: currentOperationsDoc,
+    functions,
+    fragments,
+  })
+  writeGraphQLSchemaFile({ logger, netlifyGraphConfig, schema })
   state.set('oneGraphEnabledServices', enabledServices)
 }
 
@@ -220,12 +229,13 @@ 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 {(message: string) => void=} input.logger A function that if provided will be used to log messages
  * @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 { docId, logger, netlifyGraphConfig, netlifyToken, schema, siteId } = input
   const persistedDoc = await OneGraphClient.fetchPersistedQuery(netlifyToken, siteId, docId)
   if (!persistedDoc) {
     warn(`No persisted doc found for: ${docId}`)
@@ -233,12 +243,12 @@ const updateGraphQLOperationsFileFromPersistedDoc = async (input) => {
   }
 
   // Sorts the operations stably, prepends the @netlify directive, etc.
-  const doc = normalizeOperationsDoc(persistedDoc.query)
+  const operationsDocString = normalizeOperationsDoc(persistedDoc.query)
 
-  writeGraphQLOperationsSourceFile(netlifyGraphConfig, doc)
+  writeGraphQLOperationsSourceFile({ logger, netlifyGraphConfig, operationsDocString })
   regenerateFunctionsFileFromOperationsFile({ netlifyGraphConfig, schema })
 
-  const hash = quickHash(doc)
+  const hash = quickHash(operationsDocString)
 
   const relevantHasLength = 10
 
@@ -260,7 +270,12 @@ const handleCliSessionEvent = async ({ event, netlifyGraphConfig, netlifyToken,
         warn(`No operation id found in payload, ${JSON.stringify(payload, null, 2)}`)
         return
       }
-      generateHandlerByOperationId(netlifyGraphConfig, schema, payload.operationId.id, payload)
+      generateHandlerByOperationId({
+        netlifyGraphConfig,
+        schema,
+        operationId: payload.operationId.id,
+        handlerOptions: payload,
+      })
       break
     case 'OneGraphNetlifyCliSessionPersistedLibraryUpdatedEvent':
       await updateGraphQLOperationsFileFromPersistedDoc({
@@ -324,12 +339,14 @@ const detectLocalCLISessionMetadata = ({ siteRoot }) => {
   const hostname = os.hostname()
   const userInfo = os.userInfo({ encoding: 'utf-8' })
   const { username } = userInfo
+  const cliVersion = USER_AGENT
 
   const detectedMetadata = {
     gitBranch: branch,
     hostname,
     username,
     siteRoot,
+    cliVersion,
   }
 
   return detectedMetadata

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

@@ -5,7 +5,7 @@ const process = require('process')
 
 const { GraphQL, GraphQLHelpers, InternalConsole, NetlifyGraph } = require('netlify-onegraph-internal')
 
-const { detectServerSettings, error, execa, getFunctionsDir, log, warn } = require('../../utils')
+const { chalk, detectServerSettings, error, execa, getFunctionsDir, log, warn } = require('../../utils')
 
 const { printSchema } = GraphQL
 
@@ -280,10 +280,11 @@ const runPrettier = async (filePath) => {
     })
 
     await commandProcess
+    // eslint-disable-next-line unicorn/prefer-optional-catch-binding
   } catch (prettierError) {
+    // It would be nice to log this error to help debugging, but it's potentially a bit scary for the dev to see it
     if (!disablePrettierDueToPreviousError) {
       disablePrettierDueToPreviousError = true
-      warn(prettierError)
       warn("Error while running prettier, make sure you have installed it globally with 'npm i -g prettier'")
     }
   }
@@ -297,9 +298,10 @@ const runPrettier = async (filePath) => {
  * @param {string} context.operationsDoc The GraphQL operations doc to use when generating the 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
+ * @param {(message: string) => void=} context.logger A function that if provided will be used to log messages
  * @returns {void} Void, effectfully writes the generated library to the filesystem
  */
-const generateFunctionsFile = ({ fragments, functions, netlifyGraphConfig, operationsDoc, schema }) => {
+const generateFunctionsFile = ({ fragments, functions, logger, netlifyGraphConfig, operationsDoc, schema }) => {
   const { clientSource, typeDefinitionsSource } = NetlifyGraph.generateFunctionsSource(
     netlifyGraphConfig,
     schema,
@@ -309,12 +311,15 @@ const generateFunctionsFile = ({ fragments, functions, netlifyGraphConfig, opera
   )
 
   ensureNetlifyGraphPath(netlifyGraphConfig)
-  fs.writeFileSync(path.resolve(...netlifyGraphConfig.netlifyGraphImplementationFilename), clientSource, 'utf8')
-  fs.writeFileSync(
-    path.resolve(...netlifyGraphConfig.netlifyGraphTypeDefinitionsFilename),
-    typeDefinitionsSource,
-    'utf8',
-  )
+  const implementationResolvedPath = path.resolve(...netlifyGraphConfig.netlifyGraphImplementationFilename)
+  fs.writeFileSync(implementationResolvedPath, clientSource, 'utf8')
+  const implementationRelativePath = path.relative(process.cwd(), implementationResolvedPath)
+  logger && logger(`Wrote ${chalk.cyan(implementationRelativePath)}`)
+
+  const typeDefinitionsResolvedPath = path.resolve(...netlifyGraphConfig.netlifyGraphTypeDefinitionsFilename)
+  fs.writeFileSync(typeDefinitionsResolvedPath, typeDefinitionsSource, 'utf8')
+  const typeDefinitionsRelativePath = path.relative(process.cwd(), typeDefinitionsResolvedPath)
+  logger && logger(`Wrote ${chalk.cyan(typeDefinitionsRelativePath)}`)
   runPrettier(path.resolve(...netlifyGraphConfig.netlifyGraphImplementationFilename))
   runPrettier(path.resolve(...netlifyGraphConfig.netlifyGraphTypeDefinitionsFilename))
 }
@@ -340,26 +345,36 @@ const readGraphQLOperationsSourceFile = (netlifyGraphConfig) => {
 
 /**
  * Write an operations doc to the filesystem using the given NetlifyGraphConfig
- * @param {NetlifyGraph.NetlifyGraphConfig} netlifyGraphConfig
- * @param {string} operationsDocString The GraphQL operations doc to write
+ * @param {object} input
+ * @param {(message: string) => void=} input.logger A function that if provided will be used to log messages
+ * @param {NetlifyGraph.NetlifyGraphConfig} input.netlifyGraphConfig
+ * @param {string} input.operationsDocString The GraphQL operations doc to write
  */
-const writeGraphQLOperationsSourceFile = (netlifyGraphConfig, operationsDocString) => {
+const writeGraphQLOperationsSourceFile = ({ logger, netlifyGraphConfig, operationsDocString }) => {
   const graphqlSource = operationsDocString
 
   ensureNetlifyGraphPath(netlifyGraphConfig)
-  fs.writeFileSync(path.resolve(...netlifyGraphConfig.graphQLOperationsSourceFilename), graphqlSource, 'utf8')
+  const resolvedPath = path.resolve(...netlifyGraphConfig.graphQLOperationsSourceFilename)
+  fs.writeFileSync(resolvedPath, graphqlSource, 'utf8')
+  const relativePath = path.relative(process.cwd(), resolvedPath)
+  logger && logger(`Wrote ${chalk.cyan(relativePath)}`)
 }
 
 /**
  * Write a GraphQL Schema printed in SDL format to the filesystem using the given NetlifyGraphConfig
- * @param {NetlifyGraph.NetlifyGraphConfig} netlifyGraphConfig
- * @param {GraphQL.GraphQLSchema} schema The GraphQL schema to print and write to the filesystem
+ * @param {object} input
+ * @param {(message: string) => void=} input.logger A function that if provided will be used to log messages
+ * @param {NetlifyGraph.NetlifyGraphConfig} input.netlifyGraphConfig
+ * @param {GraphQL.GraphQLSchema} input.schema The GraphQL schema to print and write to the filesystem
  */
-const writeGraphQLSchemaFile = (netlifyGraphConfig, schema) => {
+const writeGraphQLSchemaFile = ({ logger, netlifyGraphConfig, schema }) => {
   const graphqlSource = printSchema(schema)
 
   ensureNetlifyGraphPath(netlifyGraphConfig)
-  fs.writeFileSync(path.resolve(...netlifyGraphConfig.graphQLSchemaFilename), graphqlSource, 'utf8')
+  const resolvedPath = path.resolve(...netlifyGraphConfig.graphQLSchemaFilename)
+  fs.writeFileSync(resolvedPath, graphqlSource, 'utf8')
+  const relativePath = path.relative(process.cwd(), resolvedPath)
+  logger && logger(`Wrote ${chalk.cyan(relativePath)}`)
 }
 
 /**
@@ -374,19 +389,21 @@ const readGraphQLSchemaFile = (netlifyGraphConfig) => {
 
 /**
  * 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} operationId The operationId to use when generating the handler
- * @param {object} handlerOptions The options to use when generating the handler
+ * @param {object} input
+ * @param {NetlifyGraph.NetlifyGraphConfig} input.netlifyGraphConfig
+ * @param {GraphQL.GraphQLSchema} input.schema The GraphQL schema to use when generating the handler
+ * @param {string} input.operationId The operationId to use when generating the handler
+ * @param {object} input.handlerOptions The options to use when generating the handler
+ * @param {(message: string) => void=} input.logger A function that if provided will be used to log messages
  * @returns
  */
-const generateHandlerByOperationId = (netlifyGraphConfig, schema, operationId, handlerOptions) => {
+const generateHandlerByOperationId = ({ handlerOptions, logger, netlifyGraphConfig, operationId, schema }) => {
   let currentOperationsDoc = readGraphQLOperationsSourceFile(netlifyGraphConfig)
   if (currentOperationsDoc.trim().length === 0) {
     currentOperationsDoc = NetlifyGraph.defaultExampleOperationsDoc
   }
 
-  const payload = {
+  const generateHandlerPayload = {
     handlerOptions,
     schema,
     netlifyGraphConfig,
@@ -394,7 +411,7 @@ const generateHandlerByOperationId = (netlifyGraphConfig, schema, operationId, h
     operationsDoc: currentOperationsDoc,
   }
 
-  const result = NetlifyGraph.generateHandlerSource(payload)
+  const result = NetlifyGraph.generateHandlerSource(generateHandlerPayload)
 
   if (!result) {
     warn(`No handler was generated for operationId ${operationId}`)
@@ -434,19 +451,23 @@ const generateHandlerByOperationId = (netlifyGraphConfig, schema, operationId, h
     const absoluteFilename = path.resolve(...filenameArr)
 
     fs.writeFileSync(absoluteFilename, content)
+    const relativePath = path.relative(process.cwd(), absoluteFilename)
+    logger && logger(`Wrote ${chalk.cyan(relativePath)}`)
     runPrettier(absoluteFilename)
   })
 }
 
 /**
  * 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
+ * @param {object} input
+ * @param {NetlifyGraph.NetlifyGraphConfig} input.netlifyGraphConfig
+ * @param {GraphQL.GraphQLSchema} input.schema The GraphQL schema to use when generating the handler
+ * @param {string} input.operationName The name of the operation to use when generating the handler
+ * @param {object} input.handlerOptions The options to use when generating the handler
+ * @param {(message: string) => void=} input.logger A function that if provided will be used to log messages
  * @returns
  */
-const generateHandlerByOperationName = (netlifyGraphConfig, schema, operationName, handlerOptions) => {
+const generateHandlerByOperationName = ({ handlerOptions, logger, netlifyGraphConfig, operationName, schema }) => {
   let currentOperationsDoc = readGraphQLOperationsSourceFile(netlifyGraphConfig)
   if (currentOperationsDoc.trim().length === 0) {
     currentOperationsDoc = NetlifyGraph.defaultExampleOperationsDoc
@@ -464,7 +485,7 @@ const generateHandlerByOperationName = (netlifyGraphConfig, schema, operationNam
     return
   }
 
-  generateHandlerByOperationId(netlifyGraphConfig, schema, operation.id, handlerOptions)
+  generateHandlerByOperationId({ logger, netlifyGraphConfig, schema, operationId: operation.id, handlerOptions })
 }
 
 // Export the minimal set of functions that are required for Netlify Graph