@sanity/cli 3.86.0 → 3.86.2-experimental.0

package/src/actions/typegen/generateAction.ts

@@ -1,15 +1,18 @@
+/* eslint-disable complexity */
+/* eslint-disable max-statements */
+/* eslint-disable max-depth */
 import {constants, mkdir, open, stat} from 'node:fs/promises'
 import {dirname, join} from 'node:path'
 import {Worker} from 'node:worker_threads'
 
-import {readConfig} from '@sanity/codegen'
-import {format as prettierFormat, resolveConfig as resolvePrettierConfig} from 'prettier'
+import {readConfig, type TypeEvaluationStats} from '@sanity/codegen'
 
 import {type CliCommandArguments, type CliCommandContext} from '../../types'
 import {getCliWorkerPath} from '../../util/cliWorker'
+import {createReceiver} from '../../util/workerChannel'
 import {
   type TypegenGenerateTypesWorkerData,
-  type TypegenGenerateTypesWorkerMessage,
+  type TypegenWorkerChannel,
 } from '../../workers/typegenGenerate'
 import {TypesGeneratedTrace} from './generate.telemetry'
 
@@ -31,6 +34,51 @@ const generatedFileWarning = `/**
  * ---------------------------------------------------------------------------------
  */\n\n`
 
+/**
+ * Helper function to format the generated file using Prettier.
+ * Handles its own file operations and error reporting.
+ */
+async function formatGeneratedFile(
+  outputPath: string,
+  output: CliCommandContext['output'],
+  spinner: ReturnType<CliCommandContext['output']['spinner']>,
+): Promise<void> {
+  // this is here because this is an ESM-only import
+  const {format: prettierFormat, resolveConfig: resolvePrettierConfig} = await import('prettier')
+
+  let formatFile
+  try {
+    // Load prettier config
+    const prettierConfig = await resolvePrettierConfig(outputPath).catch((err) => {
+      output.warn(`Failed to load prettier config: ${err.message}`)
+      return null
+    })
+
+    if (prettierConfig) {
+      spinner.text = 'Formatting generated types with Prettier...'
+      formatFile = await open(outputPath, constants.O_RDWR)
+      try {
+        const code = await formatFile.readFile()
+        const formattedCode = await prettierFormat(code.toString(), {
+          ...prettierConfig,
+          parser: 'typescript' as const,
+        })
+        await formatFile.truncate() // Truncate before writing formatted code
+        await formatFile.write(formattedCode, 0) // Write formatted code from the beginning
+        spinner.info('Formatted generated types with Prettier')
+      } catch (err) {
+        output.warn(`Failed to format generated types with Prettier: ${err.message}`)
+      } finally {
+        // Ensure the formatting file handle is closed
+        await formatFile?.close()
+      }
+    }
+  } catch (err) {
+    // Catch errors during the formatting setup (e.g., opening the formatFile)
+    output.warn(`Error during formatting setup: ${err.message}`)
+  }
+}
+
 export default async function typegenGenerateAction(
   args: CliCommandArguments<TypegenGenerateTypesCommandFlags>,
   context: CliCommandContext,
@@ -41,170 +89,157 @@ export default async function typegenGenerateAction(
   const trace = telemetry.trace(TypesGeneratedTrace)
   trace.start()
 
-  const codegenConfig = await readConfig(flags['config-path'] || 'sanity-typegen.json')
+  const typegenConfig = await readConfig(flags['config-path'] ?? 'sanity-typegen.json')
 
-  try {
-    const schemaStats = await stat(codegenConfig.schema)
-    if (!schemaStats.isFile()) {
-      throw new Error(`Schema path is not a file: ${codegenConfig.schema}`)
+  const missingSchemas: string[] = []
+  const invalidSchemas: string[] = []
+
+  for (const schemaPath of typegenConfig.schemas.map((i) => i.schemaPath)) {
+    try {
+      const schemaStats = await stat(schemaPath)
+      if (!schemaStats.isFile()) {
+        invalidSchemas.push(schemaPath)
+      }
+    } catch (err) {
+      if (err.code === 'ENOENT') {
+        missingSchemas.push(schemaPath)
+      } else {
+        throw err
+      }
     }
-  } catch (err) {
-    if (err.code === 'ENOENT') {
+  }
+
+  if (missingSchemas.length > 0 || invalidSchemas.length > 0) {
+    const errors: string[] = []
+
+    if (missingSchemas.length > 0) {
       // If the user has not provided a specific schema path (eg we're using the default), give some help
       const hint =
-        codegenConfig.schema === './schema.json' ? ` - did you run "sanity schema extract"?` : ''
-      throw new Error(`Schema file not found: ${codegenConfig.schema}${hint}`)
+        missingSchemas.length === 1 && missingSchemas[0] === './schema.json'
+          ? ' - did you run "sanity schema extract"?'
+          : ''
+      const schemaList = missingSchemas.map((path) => `  - ${path}`).join('\n')
+      errors.push(`The following schema files were not found:\n${schemaList}${hint}`)
+    }
+
+    if (invalidSchemas.length > 0) {
+      const schemaList = invalidSchemas.map((path) => `  - ${path}`).join('\n')
+      errors.push(`The following schema paths are not files:\n${schemaList}`)
     }
-    throw err
+
+    throw new Error(errors.join('\n\n'))
   }
 
-  const outputPath = join(process.cwd(), codegenConfig.generates)
+  const outputPath = join(process.cwd(), typegenConfig.generates)
   const outputDir = dirname(outputPath)
   await mkdir(outputDir, {recursive: true})
   const workerPath = await getCliWorkerPath('typegenGenerate')
 
-  const spinner = output.spinner({}).start('Generating types')
+  const spinner = output.spinner('Generating types')
 
   const worker = new Worker(workerPath, {
     workerData: {
       workDir,
-      schemaPath: codegenConfig.schema,
-      searchPath: codegenConfig.path,
-      overloadClientMethods: codegenConfig.overloadClientMethods,
+      schemas: typegenConfig.schemas,
+      searchPath: typegenConfig.path,
+      overloadClientMethods: typegenConfig.overloadClientMethods,
+      augmentGroqModule: typegenConfig.augmentGroqModule,
     } satisfies TypegenGenerateTypesWorkerData,
     // eslint-disable-next-line no-process-env
     env: process.env,
   })
 
-  const typeFile = await open(
-    outputPath,
-    // eslint-disable-next-line no-bitwise
-    constants.O_TRUNC | constants.O_CREAT | constants.O_WRONLY,
-  )
-
-  typeFile.write(generatedFileWarning)
+  const receiver = createReceiver<TypegenWorkerChannel>(worker)
 
+  let fileHandle
   const stats = {
     queryFilesCount: 0,
-    errors: 0,
     queriesCount: 0,
+    projectionsCount: 0,
     schemaTypesCount: 0,
-    unknownTypeNodesGenerated: 0,
-    typeNodesGenerated: 0,
-    emptyUnionTypeNodesGenerated: 0,
-    size: 0,
+    typeEvaluationStats: null as TypeEvaluationStats | null,
+    outputSize: 0,
+    filesWithErrors: 0,
   }
 
-  await new Promise<void>((resolve, reject) => {
-    worker.addListener('message', (msg: TypegenGenerateTypesWorkerMessage) => {
-      if (msg.type === 'error') {
-        if (msg.fatal) {
-          trace.error(msg.error)
-          reject(msg.error)
-          return
-        }
-        const errorMessage = msg.filename
-          ? `${msg.error.message} in "${msg.filename}"`
-          : msg.error.message
-        spinner.fail(errorMessage)
-        stats.errors++
-        return
-      }
-      if (msg.type === 'complete') {
-        resolve()
-        return
-      }
-
-      if (msg.type === 'typemap') {
-        let typeMapStr = `// Query TypeMap\n`
-        typeMapStr += msg.typeMap
-        typeFile.write(typeMapStr)
-        stats.size += Buffer.byteLength(typeMapStr)
-        return
-      }
+  try {
+    try {
+      spinner.start()
 
-      let fileTypeString = `// Source: ${msg.filename}\n`
+      fileHandle = await open(outputPath, 'w')
+      await fileHandle.write(generatedFileWarning)
 
-      if (msg.type === 'schema') {
-        stats.schemaTypesCount += msg.length
-        fileTypeString += msg.schema
-        typeFile.write(fileTypeString)
-        return
-      }
+      spinner.text = 'Generating schema types...'
+      const {code: schemaCode, schemas} = await receiver.event.schema()
+      stats.schemaTypesCount = schemas.reduce((total, schema) => total + schema.typeCount, 0)
+      await fileHandle.write(schemaCode)
 
-      if (msg.type === 'types') {
+      spinner.text = 'Generating query types...'
+      for await (const queryResult of receiver.stream.queries()) {
         stats.queryFilesCount++
-        for (const {
-          queryName,
-          query,
-          type,
-          typeNodesGenerated,
-          unknownTypeNodesGenerated,
-          emptyUnionTypeNodesGenerated,
-        } of msg.types) {
-          fileTypeString += `// Variable: ${queryName}\n`
-          fileTypeString += `// Query: ${query.replace(/(\r\n|\n|\r)/gm, '').trim()}\n`
-          fileTypeString += type
-          stats.queriesCount++
-          stats.typeNodesGenerated += typeNodesGenerated
-          stats.unknownTypeNodesGenerated += unknownTypeNodesGenerated
-          stats.emptyUnionTypeNodesGenerated += emptyUnionTypeNodesGenerated
+        const {error, results} = queryResult
+        if (error) {
+          stats.filesWithErrors++
+        }
+        for (const result of results) {
+          await fileHandle.write(result.code)
+          if (result.type === 'projection') {
+            stats.projectionsCount++
+          } else {
+            stats.queriesCount++
+          }
         }
-        typeFile.write(`${fileTypeString}\n`)
-        stats.size += Buffer.byteLength(fileTypeString)
       }
-    })
-    worker.addListener('error', reject)
-  })
-
-  await typeFile.close()
 
-  const prettierConfig = codegenConfig.formatGeneratedCode
-    ? await resolvePrettierConfig(outputPath).catch((err) => {
-        output.warn(`Failed to load prettier config: ${err.message}`)
-        return null
-      })
-    : null
-
-  if (prettierConfig) {
-    const formatFile = await open(outputPath, constants.O_RDWR)
-    try {
-      const code = await formatFile.readFile()
-      const formattedCode = await prettierFormat(code.toString(), {
-        ...prettierConfig,
-        parser: 'typescript' as const,
-      })
-      await formatFile.truncate()
-      await formatFile.write(formattedCode, 0)
-
-      spinner.info('Formatted generated types with Prettier')
-    } catch (err) {
-      output.warn(`Failed to format generated types with Prettier: ${err.message}`)
+      spinner.text = 'Generating typemap...'
+      const {code: typemapCode, stats: finalStats} = await receiver.event.typemap()
+      stats.typeEvaluationStats = finalStats
+      await fileHandle.write(typemapCode)
     } finally {
-      await formatFile.close()
+      // Ensure the initial file handle is closed before moving on
+      await fileHandle?.close()
     }
-  }
 
-  trace.log({
-    outputSize: stats.size,
-    queriesCount: stats.queriesCount,
-    schemaTypesCount: stats.schemaTypesCount,
-    queryFilesCount: stats.queryFilesCount,
-    filesWithErrors: stats.errors,
-    typeNodesGenerated: stats.typeNodesGenerated,
-    unknownTypeNodesGenerated: stats.unknownTypeNodesGenerated,
-    unknownTypeNodesRatio:
-      stats.typeNodesGenerated > 0 ? stats.unknownTypeNodesGenerated / stats.typeNodesGenerated : 0,
-    emptyUnionTypeNodesGenerated: stats.emptyUnionTypeNodesGenerated,
-    configOverloadClientMethods: codegenConfig.overloadClientMethods,
-  })
+    if (typegenConfig.formatGeneratedCode) {
+      await formatGeneratedFile(outputPath, output, spinner)
+    }
 
-  trace.complete()
-  if (stats.errors > 0) {
-    spinner.warn(`Encountered errors in ${stats.errors} files while generating types`)
-  }
+    // Gather final stats and report success
+    const finalStat = await stat(outputPath)
+    stats.outputSize = finalStat.size
+
+    trace.log({
+      outputSize: stats.outputSize,
+      queriesCount: stats.queriesCount,
+      projectionsCount: stats.projectionsCount,
+      schemaTypesCount: stats.schemaTypesCount,
+      queryFilesCount: stats.queryFilesCount,
+      filesWithErrors: stats.filesWithErrors,
+      typeNodesGenerated: stats.typeEvaluationStats?.totalTypeNodes,
+      unknownTypeNodesGenerated: stats.typeEvaluationStats?.unknownTypeCount,
+      unknownTypeNodesRatio:
+        stats.typeEvaluationStats && stats.typeEvaluationStats.totalTypeNodes > 0
+          ? stats.typeEvaluationStats.unknownTypeCount / stats.typeEvaluationStats.totalTypeNodes
+          : 0,
+      emptyUnionTypeNodesGenerated: stats.typeEvaluationStats?.emptyUnionCount,
+      configOverloadClientMethods: typegenConfig.overloadClientMethods,
+      configAugmentGroqModule: typegenConfig.augmentGroqModule,
+    })
+
+    trace.complete()
+    if (stats.filesWithErrors > 0) {
+      spinner.warn(`Encountered errors in ${stats.filesWithErrors} files while generating types`)
+    }
 
-  spinner.succeed(
-    `Generated TypeScript types for ${stats.schemaTypesCount} schema types and ${stats.queriesCount} GROQ queries in ${stats.queryFilesCount} files into: ${codegenConfig.generates}`,
-  )
+    spinner.succeed(
+      `Generated TypeScript types for ${stats.schemaTypesCount} schema types, ${stats.queriesCount} GROQ queries, ${stats.projectionsCount} GROQ projections, in ${stats.queryFilesCount} files into: ${typegenConfig.generates}`,
+    )
+  } catch (err) {
+    spinner.fail('Type generation failed')
+    trace.error(err instanceof Error ? err : new Error(String(err)))
+    throw err // Re-throw the error after logging
+  } finally {
+    // Ensure the worker receiver is always disposed
+    await receiver.dispose()
+  }
 }

package/src/commands/functions/envFunctionsCommand.ts

@@ -5,25 +5,25 @@ import {type CliCommandDefinition} from '../../types'
 type StackFunctionResource = types.StackFunctionResource
 
 const helpText = `
+Arguments
+  [add] Add or update an environment variable
+  [remove] Remove an environment variable
+
 Options
   --name <name> The name of the function
-  --add Add or update an environment variable
-  --remove Remove an environment variable
   --key <key> The name of the environment variable
   --value <value> The value of the environment variable
 
 Examples
   # Add or update an environment variable
-  sanity functions env --name echo --add --key API_URL --value https://api.example.com/
+  sanity functions env add --name echo --key API_URL --value https://api.example.com/
 
   # Remove an environment variable
-  sanity functions env --name echo --remove --key API_URL
+  sanity functions env remove --name echo --key API_URL
 `
 
 const defaultFlags = {
   name: '',
-  add: false,
-  remove: false,
   key: '',
   value: '',
 }
@@ -38,16 +38,20 @@ const envFunctionsCommand: CliCommandDefinition = {
   async action(args, context) {
     const {apiClient, output} = context
     const {print} = output
+    const [subCommand] = args.argsWithoutOptions
     const flags = {...defaultFlags, ...args.extOptions}
 
+    if (!subCommand || !['add', 'remove'].includes(subCommand)) {
+      throw new Error('You must specify if you wish to add or remove an environment variable')
+    }
+
     const client = apiClient({
       requireUser: true,
       requireProject: false,
     })
 
     if (flags.name === '') {
-      print('You must provide a function name')
-      return
+      throw new Error('You must provide a function name via the --name flag')
     }
 
     const token = client.config().token
@@ -61,8 +65,7 @@ const envFunctionsCommand: CliCommandDefinition = {
     })
 
     if (!deployedStack) {
-      print('Stack not found')
-      return
+      throw new Error('Stack not found')
     }
 
     const blueprintConfig = blueprint.readConfigFile()
@@ -74,7 +77,7 @@ const envFunctionsCommand: CliCommandDefinition = {
     ) as StackFunctionResource
 
     if (token && projectId) {
-      if (flags.add) {
+      if (subCommand === 'add') {
         print(`Updating "${flags.key}" environment variable in "${flags.name}"`)
         const result = await env.update.update(externalId, flags.key, flags.value, {
           token,
@@ -86,7 +89,7 @@ const envFunctionsCommand: CliCommandDefinition = {
           print(`Failed to update ${flags.key}`)
           print(`Error: ${result.error || 'Unknown error'}`)
         }
-      } else if (flags.remove) {
+      } else if (subCommand === 'remove') {
         print(`Removing "${flags.key}" environment variable in "${flags.name}"`)
         const result = await env.remove.remove(externalId, flags.key, {
           token,

package/src/commands/functions/logsFunctionsCommand.ts

@@ -7,8 +7,9 @@ type StackFunctionResource = types.StackFunctionResource
 const helpText = `
 Options
   --name <name> The name of the function to retrieve logs for
-  --limit <limit> The number of log entries to retrieve
+  --limit <limit> The number of log entries to retrieve [default 50]
   --json If set return json
+  --utc Use UTC dates in logs
 
 Examples
   # Retrieve logs for Sanity Function abcd1234
@@ -25,6 +26,7 @@ const defaultFlags = {
   name: '',
   limit: 50,
   json: false,
+  utc: false,
 }
 
 const logsFunctionsCommand: CliCommandDefinition = {
@@ -45,8 +47,7 @@ const logsFunctionsCommand: CliCommandDefinition = {
     })
 
     if (flags.name === '') {
-      print('You must provide a function name')
-      return
+      throw new Error('You must provide a function name via the --name flag')
     }
 
     const token = client.config().token
@@ -59,8 +60,7 @@ const logsFunctionsCommand: CliCommandDefinition = {
     })
 
     if (!deployedStack) {
-      print('Stack not found')
-      return
+      throw new Error('Stack not found')
     }
 
     const blueprintConfig = blueprint.readConfigFile()
@@ -105,7 +105,10 @@ const logsFunctionsCommand: CliCommandDefinition = {
         for (const log of filteredLogs) {
           const {time, level, message} = log
           const date = new Date(time)
-          print(`${date.toLocaleDateString()} ${date.toLocaleTimeString()} ${level} ${message}`)
+          const dateString = flags.utc
+            ? date.toISOString().slice(0, 19).split('T').join(' ')
+            : `${date.toLocaleDateString()} ${date.toLocaleTimeString()}`
+          print(`${dateString} ${level} ${message}`)
         }
       }
     } else {

package/src/commands/functions/testFunctionsCommand.ts

@@ -38,8 +38,7 @@ const testFunctionsCommand: CliCommandDefinition = {
     const flags = {...defaultFlags, ...args.extOptions}
 
     if (flags.name === '') {
-      print('You must provide a function name')
-      return
+      throw new Error('You must provide a function name via the --name flag')
     }
 
     const {test} = await import('@sanity/runtime-cli/actions/functions')
@@ -52,7 +51,7 @@ const testFunctionsCommand: CliCommandDefinition = {
 
     const src = findFunction.getFunctionSource(parsedBlueprint, flags.name)
     if (!src) {
-      print(`Error: Function ${flags.name} has no source code`)
+      throw new Error(`Error: Function ${flags.name} has no source code`)
     }
 
     const {json, logs, error} = await test.testAction(