@sanity/cli 3.88.1-typegen-experimental.0 → 3.88.1

package/src/actions/typegen/generateAction.ts

@@ -1,17 +1,15 @@
-/* eslint-disable max-statements */
 import {constants, mkdir, open, stat} from 'node:fs/promises'
 import {dirname, join} from 'node:path'
-import process from 'node:process'
 import {Worker} from 'node:worker_threads'
 
-import {DEFAULT_CONFIG, readConfig} 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'
 
@@ -19,8 +17,7 @@ export interface TypegenGenerateTypesCommandFlags {
   'config-path'?: string
 }
 
-const DEFAULT_CONFIG_PATH = 'sanity-typegen.json'
-const GENERATED_FILE_WARNING = `/**
+const generatedFileWarning = `/**
  * ---------------------------------------------------------------------------------
  * This file has been generated by Sanity TypeGen.
  * Command: \`sanity typegen generate\`
@@ -34,20 +31,6 @@ const GENERATED_FILE_WARNING = `/**
  * ---------------------------------------------------------------------------------
  */\n\n`
 
-const percentageFormatter = new Intl.NumberFormat('en-US', {
-  style: 'percent',
-  minimumFractionDigits: 1,
-  maximumFractionDigits: 1,
-})
-
-const percent = (value: number): string => percentageFormatter.format(Math.min(value, 1))
-
-const count = (
-  amount: number,
-  plural: string,
-  singular: string = plural.slice(0, Math.max(0, plural.length - 1)),
-): string => `${amount.toLocaleString('en-US')} ${amount === 1 ? singular : plural}`
-
 export default async function typegenGenerateAction(
   args: CliCommandArguments<TypegenGenerateTypesCommandFlags>,
   context: CliCommandContext,
@@ -58,160 +41,170 @@ export default async function typegenGenerateAction(
   const trace = telemetry.trace(TypesGeneratedTrace)
   trace.start()
 
-  const spinner = output.spinner('Generating types…')
-  spinner.start()
+  const codegenConfig = await readConfig(flags['config-path'] || 'sanity-typegen.json')
 
-  let codegenConfig
-  const configPath = flags['config-path'] ?? DEFAULT_CONFIG_PATH
   try {
-    codegenConfig = await readConfig(configPath)
-    spinner.info(`Using typegen configuration found at "${configPath}"`)
-  } catch (error) {
-    if (error?.code !== 'ENOENT') throw error
-    codegenConfig = DEFAULT_CONFIG
-
-    if (configPath !== DEFAULT_CONFIG_PATH) {
-      spinner.warn(
-        `Configuration file not found at specified path "${configPath}". Falling back to default settings.`,
-      )
+    const schemaStats = await stat(codegenConfig.schema)
+    if (!schemaStats.isFile()) {
+      throw new Error(`Schema path is not a file: ${codegenConfig.schema}`)
     }
+  } 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 =
+        codegenConfig.schema === './schema.json' ? ` - did you run "sanity schema extract"?` : ''
+      throw new Error(`Schema file not found: ${codegenConfig.schema}${hint}`)
+    }
+    throw err
   }
-  const {
-    schemas,
-    augmentGroqModule,
-    formatGeneratedCode,
-    generates,
-    overloadClientMethods,
-    path: searchPath,
-  } = codegenConfig
-
-  spinner.start(`Loading schema${schemas.length === 1 ? '' : 's'}…`)
-
-  const outputPath = join(process.cwd(), generates)
-  await mkdir(dirname(outputPath), {recursive: true})
-
-  const workerData: TypegenGenerateTypesWorkerData = {
-    workDir,
-    schemas,
-    searchPath,
-    overloadClientMethods,
-    augmentGroqModule,
-  }
-  const worker = new Worker(await getCliWorkerPath('typegenGenerate'), {
-    workerData,
+
+  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({}).start('Generating types')
+
+  const worker = new Worker(workerPath, {
+    workerData: {
+      workDir,
+      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)
 
-  let fileHandle
-  let schemaStats
-  let queryStats
+  const typeFile = await open(
+    outputPath,
+    // eslint-disable-next-line no-bitwise
+    constants.O_TRUNC | constants.O_CREAT | constants.O_WRONLY,
+  )
+
+  typeFile.write(generatedFileWarning)
+
+  const stats = {
+    queryFilesCount: 0,
+    errors: 0,
+    queriesCount: 0,
+    schemaTypesCount: 0,
+    unknownTypeNodesGenerated: 0,
+    typeNodesGenerated: 0,
+    emptyUnionTypeNodesGenerated: 0,
+    size: 0,
+  }
 
-  try {
-    await receiver.event.loadedSchemas()
-    spinner.succeed(
-      schemas.length === 1
-        ? `Loaded schema from ${schemas[0].schemaPath}`
-        : `Loaded ${count(schemas.length, 'schemas')}`,
-    )
-
-    spinner.start('Generating schema types…')
-    fileHandle = await open(outputPath, 'w')
-    await fileHandle.write(GENERATED_FILE_WARNING)
-    const schemaResult = await receiver.event.generatedSchemaDeclarations()
-    schemaStats = schemaResult.schemaStats
-    await fileHandle.write(schemaResult.code)
-
-    const schemaTypesCount = count(schemaStats.schemaTypesCount, 'schema types')
-    const schemaCount = count(schemaStats.schemaCount, 'schemas')
-    spinner.succeed(
-      `Generated ${schemaTypesCount}${schemas.length > 1 ? ` from ${schemaCount}` : ''}`,
-    )
-
-    spinner.start('Generating query types…')
-    const expectedFiles = (await receiver.event.fileCount()).fileCount
-    const expectedFileCount = count(expectedFiles, 'files')
-
-    for await (const {
-      progress,
-      ...queryResult
-    } of receiver.stream.generatedQueryResultDeclaration()) {
-      const queryCount = count(progress.queriesCount, 'queries', 'query')
-      const projectionCount = count(progress.projectionsCount, 'projections')
-      spinner.text =
-        `Generating query types… (${percent(progress.filesCount / expectedFiles)})\n` +
-        `  └─ Processed ${progress.filesCount} of ${expectedFileCount}. Found ${queryCount}, ${projectionCount}.`
-
-      if (queryResult.type === 'error') {
-        spinner.fail(queryResult.message)
+  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 (queryResult.type === 'declaration') {
-        await fileHandle.write(queryResult.code)
+      if (msg.type === 'complete') {
+        resolve()
+        return
       }
-    }
 
-    const result = await receiver.event.generationComplete()
-    queryStats = result.queryStats
-    await fileHandle.write(result.augmentedQueryResultDeclarations.code)
-    await fileHandle.close()
-    fileHandle = null
-
-    const queryTypesCount = count(queryStats.queriesCount, 'query types')
-    const projectionTypesCount = count(queryStats.projectionsCount, 'projection types')
-    const scannedFilesCount = count(queryStats.totalScannedFilesCount, 'scanned files')
-    spinner.succeed(
-      `Generated ${queryTypesCount} and ${projectionTypesCount} from ${scannedFilesCount}`,
-    )
-
-    if (formatGeneratedCode) {
-      spinner.start(`Formatting generated types with prettier…`)
-
-      try {
-        const prettier = await import('prettier')
-        const prettierConfig = await prettier.resolveConfig(outputPath)
-
-        fileHandle = await open(outputPath, constants.O_RDWR)
-        const code = await fileHandle.readFile({encoding: 'utf-8'})
-        const formattedCode = await prettier.format(code, {
-          ...prettierConfig,
-          parser: 'typescript' as const,
-        })
-        await fileHandle.truncate()
-        await fileHandle.write(formattedCode, 0)
-        await fileHandle.close()
-        fileHandle = null
-
-        spinner.succeed('Formatted generated types with prettier')
-      } catch (err) {
-        spinner.warn(`Failed to format generated types with prettier: ${err.message}`)
+      if (msg.type === 'typemap') {
+        let typeMapStr = `// Query TypeMap\n`
+        typeMapStr += msg.typeMap
+        typeFile.write(typeMapStr)
+        stats.size += Buffer.byteLength(typeMapStr)
+        return
       }
-    }
 
-    // Gather final stats and report success
-    const outputStat = await stat(outputPath)
+      let fileTypeString = `// Source: ${msg.filename}\n`
+
+      if (msg.type === 'schema') {
+        stats.schemaTypesCount += msg.length
+        fileTypeString += msg.schema
+        typeFile.write(fileTypeString)
+        return
+      }
 
-    trace.log({
-      outputSize: outputStat.size,
-      ...schemaStats,
-      ...queryStats,
-      configOverloadClientMethods: overloadClientMethods,
-      configAugmentGroqModule: augmentGroqModule,
+      if (msg.type === 'types') {
+        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
+        }
+        typeFile.write(`${fileTypeString}\n`)
+        stats.size += Buffer.byteLength(fileTypeString)
+      }
     })
+    worker.addListener('error', reject)
+  })
 
-    if (queryStats.errorCount > 0) {
-      spinner.warn(
-        `Encountered ${count(queryStats.errorCount, 'errors')} in ${count(queryStats.filesWithErrors, 'files')} while generating types to ${generates}`,
-      )
-    } else {
-      spinner.succeed(`Successfully generated types to ${generates}`)
+  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}`)
+    } finally {
+      await formatFile.close()
     }
-  } catch (err) {
-    trace.error(err)
-    throw err
-  } finally {
-    await fileHandle?.close()
-    await receiver.dispose()
-    trace.complete()
   }
+
+  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}`,
+  )
 }