@sanity/cli 3.86.2-experimental.0 → 3.87.1-canary.4

package/src/actions/typegen/generateAction.ts

@@ -1,18 +1,15 @@
-/* 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, type TypeEvaluationStats} from '@sanity/codegen'
+import {readConfig} from '@sanity/codegen'
+import {format as prettierFormat, resolveConfig as resolvePrettierConfig} from 'prettier'
 
 import {type CliCommandArguments, type CliCommandContext} from '../../types'
 import {getCliWorkerPath} from '../../util/cliWorker'
-import {createReceiver} from '../../util/workerChannel'
 import {
   type TypegenGenerateTypesWorkerData,
-  type TypegenWorkerChannel,
+  type TypegenGenerateTypesWorkerMessage,
 } from '../../workers/typegenGenerate'
 import {TypesGeneratedTrace} from './generate.telemetry'
 
@@ -34,51 +31,6 @@ 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,
@@ -89,157 +41,170 @@ export default async function typegenGenerateAction(
   const trace = telemetry.trace(TypesGeneratedTrace)
   trace.start()
 
-  const typegenConfig = await readConfig(flags['config-path'] ?? 'sanity-typegen.json')
-
-  const missingSchemas: string[] = []
-  const invalidSchemas: string[] = []
+  const codegenConfig = await readConfig(flags['config-path'] || 'sanity-typegen.json')
 
-  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
-      }
+  try {
+    const schemaStats = await stat(codegenConfig.schema)
+    if (!schemaStats.isFile()) {
+      throw new Error(`Schema path is not a file: ${codegenConfig.schema}`)
     }
-  }
-
-  if (missingSchemas.length > 0 || invalidSchemas.length > 0) {
-    const errors: string[] = []
-
-    if (missingSchemas.length > 0) {
+  } catch (err) {
+    if (err.code === 'ENOENT') {
       // If the user has not provided a specific schema path (eg we're using the default), give some help
       const 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}`)
+        codegenConfig.schema === './schema.json' ? ` - did you run "sanity schema extract"?` : ''
+      throw new Error(`Schema file not found: ${codegenConfig.schema}${hint}`)
     }
-
-    throw new Error(errors.join('\n\n'))
+    throw err
   }
 
-  const outputPath = join(process.cwd(), typegenConfig.generates)
+  const outputPath = join(process.cwd(), codegenConfig.generates)
   const outputDir = dirname(outputPath)
   await mkdir(outputDir, {recursive: true})
   const workerPath = await getCliWorkerPath('typegenGenerate')
 
-  const spinner = output.spinner('Generating types')
+  const spinner = output.spinner({}).start('Generating types')
 
   const worker = new Worker(workerPath, {
     workerData: {
       workDir,
-      schemas: typegenConfig.schemas,
-      searchPath: typegenConfig.path,
-      overloadClientMethods: typegenConfig.overloadClientMethods,
-      augmentGroqModule: typegenConfig.augmentGroqModule,
+      schemaPath: codegenConfig.schema,
+      searchPath: codegenConfig.path,
+      overloadClientMethods: codegenConfig.overloadClientMethods,
     } satisfies TypegenGenerateTypesWorkerData,
     // eslint-disable-next-line no-process-env
     env: process.env,
   })
 
-  const receiver = createReceiver<TypegenWorkerChannel>(worker)
+  const typeFile = await open(
+    outputPath,
+    // eslint-disable-next-line no-bitwise
+    constants.O_TRUNC | constants.O_CREAT | constants.O_WRONLY,
+  )
+
+  typeFile.write(generatedFileWarning)
 
-  let fileHandle
   const stats = {
     queryFilesCount: 0,
+    errors: 0,
     queriesCount: 0,
-    projectionsCount: 0,
     schemaTypesCount: 0,
-    typeEvaluationStats: null as TypeEvaluationStats | null,
-    outputSize: 0,
-    filesWithErrors: 0,
+    unknownTypeNodesGenerated: 0,
+    typeNodesGenerated: 0,
+    emptyUnionTypeNodesGenerated: 0,
+    size: 0,
   }
 
-  try {
-    try {
-      spinner.start()
+  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
+      }
 
-      fileHandle = await open(outputPath, 'w')
-      await fileHandle.write(generatedFileWarning)
+      let fileTypeString = `// Source: ${msg.filename}\n`
 
-      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 === 'schema') {
+        stats.schemaTypesCount += msg.length
+        fileTypeString += msg.schema
+        typeFile.write(fileTypeString)
+        return
+      }
 
-      spinner.text = 'Generating query types...'
-      for await (const queryResult of receiver.stream.queries()) {
+      if (msg.type === 'types') {
         stats.queryFilesCount++
-        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++
-          }
+        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
         }
+        typeFile.write(`${fileTypeString}\n`)
+        stats.size += Buffer.byteLength(fileTypeString)
       }
+    })
+    worker.addListener('error', reject)
+  })
 
-      spinner.text = 'Generating typemap...'
-      const {code: typemapCode, stats: finalStats} = await receiver.event.typemap()
-      stats.typeEvaluationStats = finalStats
-      await fileHandle.write(typemapCode)
-    } finally {
-      // Ensure the initial file handle is closed before moving on
-      await fileHandle?.close()
-    }
-
-    if (typegenConfig.formatGeneratedCode) {
-      await formatGeneratedFile(outputPath, output, spinner)
-    }
+  await typeFile.close()
 
-    // 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,
-    })
+  const prettierConfig = codegenConfig.formatGeneratedCode
+    ? await resolvePrettierConfig(outputPath).catch((err) => {
+        output.warn(`Failed to load prettier config: ${err.message}`)
+        return null
+      })
+    : null
 
-    trace.complete()
-    if (stats.filesWithErrors > 0) {
-      spinner.warn(`Encountered errors in ${stats.filesWithErrors} files while generating types`)
+  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}`)
+    } finally {
+      await formatFile.close()
     }
+  }
 
-    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()
+  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,
+  })
+
+  trace.complete()
+  if (stats.errors > 0) {
+    spinner.warn(`Encountered errors in ${stats.errors} 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}`,
+  )
 }

package/src/cli.ts

@@ -56,9 +56,6 @@ export async function runCli(cliRoot: string, {cliVersion}: {cliVersion: string}
     process.exit(1)
   }
 
-  loadAndSetEnvFromDotEnvFiles({workDir, cmd: args.groupOrCommand})
-  maybeFixMissingWindowsEnvVar()
-
   // Check if there are updates available for the CLI, and notify if there is
   await runUpdateCheck({pkg, cwd, workDir}).notify()
 
@@ -67,11 +64,20 @@ export async function runCli(cliRoot: string, {cliVersion}: {cliVersion: string}
 
   // Try to figure out if we're in a v2 or v3 context by finding a config
   debug(`Reading CLI config from "${workDir}"`)
-  const cliConfig = await getCliConfig(workDir, {forked: true})
+  let cliConfig = await getCliConfig(workDir, {forked: true})
   if (!cliConfig) {
     debug('No CLI config found')
   }
 
+  // Figure out if the app is a studio or an app from the CLI config
+  const isApp = Boolean(cliConfig && 'app' in cliConfig)
+  // Load the environment variables from
+  loadAndSetEnvFromDotEnvFiles({workDir, cmd: args.groupOrCommand, isApp})
+  maybeFixMissingWindowsEnvVar()
+
+  // Reload the the cli config so env vars can work.
+  cliConfig = await getCliConfig(workDir, {forked: true})
+
   const {logger: telemetry, flush: flushTelemetry} = createTelemetryStore<TelemetryUserProperties>({
     projectId: cliConfig?.config?.api?.projectId,
     env: process.env,
@@ -274,7 +280,15 @@ function warnOnNonProductionEnvironment(): void {
   )
 }
 
-function loadAndSetEnvFromDotEnvFiles({workDir, cmd}: {workDir: string; cmd: string}) {
+function loadAndSetEnvFromDotEnvFiles({
+  workDir,
+  cmd,
+  isApp,
+}: {
+  workDir: string
+  cmd: string
+  isApp: boolean
+}) {
   /* eslint-disable no-process-env */
 
   // Do a cheap lookup for a sanity.json file. If there is one, assume it is a v2 project,
@@ -309,7 +323,7 @@ function loadAndSetEnvFromDotEnvFiles({workDir, cmd}: {workDir: string; cmd: str
 
   debug('Loading environment files using %s mode', mode)
 
-  const studioEnv = loadEnv(mode, workDir, ['SANITY_STUDIO_'])
+  const studioEnv = loadEnv(mode, workDir, [isApp ? 'SANITY_APP_' : 'SANITY_STUDIO_'])
   process.env = {...process.env, ...studioEnv}
   /* eslint-disable no-process-env */
 }

package/src/util/journeyConfig.ts

@@ -7,6 +7,7 @@ import {
   type DocumentDefinition,
   type ObjectDefinition,
 } from '@sanity/types'
+import {format} from 'prettier'
 
 import {type CliApiClient} from '../types'
 import {getCliWorkerPath} from './cliWorker'
@@ -183,7 +184,6 @@ async function fetchJourneySchema(schemaUrl: string): Promise<DocumentOrObject[]
 async function assembleJourneySchemaTypeFileContent(schemaType: DocumentOrObject): Promise<string> {
   const serialised = wrapSchemaTypeInHelpers(schemaType)
   const imports = getImports(serialised)
-  const {format} = await import('prettier')
   const prettifiedSchemaType = await format(serialised, {
     parser: 'typescript',
     printWidth: 40,
@@ -198,12 +198,11 @@ async function assembleJourneySchemaTypeFileContent(schemaType: DocumentOrObject
  * @param schemas - The Journey schemas to assemble into an index file
  * @returns The index file as a string
  */
-async function assembleJourneyIndexContent(schemas: DocumentOrObject[]): Promise<string> {
+function assembleJourneyIndexContent(schemas: DocumentOrObject[]): Promise<string> {
   const sortedSchema = schemas.slice().sort((a, b) => (a.name > b.name ? 1 : -1))
   const imports = sortedSchema.map((schema) => `import { ${schema.name} } from './${schema.name}'`)
   const exports = sortedSchema.map((schema) => schema.name).join(',')
   const fileContents = `${imports.join('\n')}\n\nexport const schemaTypes = [${exports}]`
-  const {format} = await import('prettier')
   return format(fileContents, {parser: 'typescript'})
 }