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

package/src/actions/typegen/generateAction.ts

@@ -1,15 +1,17 @@
+/* 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 {readConfig} from '@sanity/codegen'
-import {format as prettierFormat, resolveConfig as resolvePrettierConfig} from 'prettier'
+import {DEFAULT_CONFIG, readConfig} 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'
 
@@ -17,7 +19,8 @@ export interface TypegenGenerateTypesCommandFlags {
   'config-path'?: string
 }
 
-const generatedFileWarning = `/**
+const DEFAULT_CONFIG_PATH = 'sanity-typegen.json'
+const GENERATED_FILE_WARNING = `/**
  * ---------------------------------------------------------------------------------
  * This file has been generated by Sanity TypeGen.
  * Command: \`sanity typegen generate\`
@@ -31,6 +34,20 @@ const generatedFileWarning = `/**
  * ---------------------------------------------------------------------------------
  */\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,
@@ -41,170 +58,160 @@ export default async function typegenGenerateAction(
   const trace = telemetry.trace(TypesGeneratedTrace)
   trace.start()
 
-  const codegenConfig = await readConfig(flags['config-path'] || 'sanity-typegen.json')
+  const spinner = output.spinner('Generating types…')
+  spinner.start()
 
+  let codegenConfig
+  const configPath = flags['config-path'] ?? DEFAULT_CONFIG_PATH
   try {
-    const schemaStats = await stat(codegenConfig.schema)
-    if (!schemaStats.isFile()) {
-      throw new Error(`Schema path is not a file: ${codegenConfig.schema}`)
+    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.`,
+      )
     }
-  } 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 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
+  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,
     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)
-
-  const stats = {
-    queryFilesCount: 0,
-    errors: 0,
-    queriesCount: 0,
-    schemaTypesCount: 0,
-    unknownTypeNodesGenerated: 0,
-    typeNodesGenerated: 0,
-    emptyUnionTypeNodesGenerated: 0,
-    size: 0,
-  }
+  let fileHandle
+  let schemaStats
+  let queryStats
 
-  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
+  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)
       }
 
-      if (msg.type === 'typemap') {
-        let typeMapStr = `// Query TypeMap\n`
-        typeMapStr += msg.typeMap
-        typeFile.write(typeMapStr)
-        stats.size += Buffer.byteLength(typeMapStr)
-        return
+      if (queryResult.type === 'declaration') {
+        await fileHandle.write(queryResult.code)
       }
+    }
 
-      let fileTypeString = `// Source: ${msg.filename}\n`
-
-      if (msg.type === 'schema') {
-        stats.schemaTypesCount += msg.length
-        fileTypeString += msg.schema
-        typeFile.write(fileTypeString)
-        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 === '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)
-      }
+    // Gather final stats and report success
+    const outputStat = await stat(outputPath)
+
+    trace.log({
+      outputSize: outputStat.size,
+      ...schemaStats,
+      ...queryStats,
+      configOverloadClientMethods: overloadClientMethods,
+      configAugmentGroqModule: augmentGroqModule,
     })
-    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}`)
-    } finally {
-      await formatFile.close()
+    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}`)
     }
+  } 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}`,
-  )
 }

package/src/commands/blueprints/addBlueprintsCommand.ts

@@ -2,79 +2,75 @@ import {type CliCommandDefinition} from '../../types'
 
 const helpText = `
 Arguments
-  [type]  Type of Resource to add (currently only 'function' is supported)
+  <type>  Type of Resource to add (currently only 'function' is supported)
 
-Examples
-  # Add a Function Resource
+Options
+  --name <name>                Name of the Resource
+  --fn-type <type>             Type of Function Resource to add (e.g. document-publish)
+  --fn-lang, --lang <ts|js>    Language of the Function Resource
+  --js, --javascript           Use JavaScript for the Function Resource
+
+Examples:
+  # Add a Function Resource (TypeScript by default)
   sanity blueprints add function
+
+  # Add a Function Resource with a specific name
+  sanity blueprints add function --name my-function
+
+  # Add a Function Resource with a specific type
+  sanity blueprints add function --name my-function --fn-type document-publish
+
+  # Add a Function Resource in JavaScript
+  sanity blueprints add function --name my-function --fn-type document-publish --js
 `
 
-const addBlueprintsCommand: CliCommandDefinition = {
+export interface BlueprintsAddFlags {
+  'name'?: string
+  'fn-type'?: string
+  'fn-lang'?: string
+  'language'?: string
+  'lang'?: string
+  'js'?: boolean
+  'javascript'?: boolean
+}
+
+const defaultFlags: BlueprintsAddFlags = {
+  //
+}
+
+const addBlueprintsCommand: CliCommandDefinition<BlueprintsAddFlags> = {
   name: 'add',
   group: 'blueprints',
   helpText,
-  signature: '<type>',
+  signature:
+    '<type> [--name <name>] [--fn-type <document-publish>] [--fn-lang <ts|js>] [--javascript]',
   description: 'Add a Resource to a Blueprint',
-  hideFromHelp: true,
+
   async action(args, context) {
-    const {output, prompt} = context
-    const {print} = output
+    const {output} = context
+    const flags = {...defaultFlags, ...args.extOptions}
 
     const [resourceType] = args.argsWithoutOptions
 
     if (!resourceType) {
-      print('Resource type is required. Available types: function')
-      return
-    }
-
-    const {blueprint: blueprintAction, resources: resourcesAction} = await import(
-      '@sanity/runtime-cli/actions/blueprints'
-    )
-
-    const existingBlueprint = blueprintAction.findBlueprintFile()
-    if (!existingBlueprint) {
-      print('No blueprint file found. Run `sanity blueprints init` first.')
+      output.error('Resource type is required. Available types: function')
       return
     }
 
-    if (resourceType === 'function') {
-      const functionName = await prompt.single({
-        type: 'input',
-        message: 'Enter function name:',
-        validate: (input: string) => input.length > 0 || 'Function name is required',
-      })
-
-      const functionType = await prompt.single({
-        type: 'list',
-        message: 'Choose function type:',
-        choices: [
-          {value: 'document-publish', name: 'Document Publish'},
-          {value: 'document-create', name: 'Document Create (Available soon)', disabled: true},
-          {value: 'document-delete', name: 'Document Delete (Available soon)', disabled: true},
-        ],
-      })
-
-      const {filePath, resourceAdded, resource} = resourcesAction.createFunctionResource({
-        name: functionName,
-        type: functionType,
-        displayName: functionName,
-      })
-
-      print(`\nCreated function: ${filePath}`)
-
-      if (resourceAdded) {
-        // added to blueprint.json
-        print('Function Resource added to Blueprint')
-      } else {
-        // print the resource JSON for manual addition
-        print('\nAdd this Function Resource to your Blueprint:')
-        print(JSON.stringify(resource, null, 2))
-      }
-
-      return
-    }
+    const {blueprintAddCore} = await import('@sanity/runtime-cli/cores/blueprints')
+    const {success, error} = await blueprintAddCore({
+      bin: 'sanity',
+      log: (msg) => output.print(msg),
+      args: {type: resourceType},
+      flags: {
+        'name': flags.name,
+        'fn-type': flags['fn-type'],
+        'language': flags['fn-lang'] ?? flags.language ?? flags.lang,
+        'javascript': flags.js || flags.javascript,
+      },
+    })
 
-    print(`Unsupported resource type: ${resourceType}. Available types: function`)
+    if (!success) throw new Error(error)
   },
 }
 

package/src/commands/blueprints/blueprintsGroup.ts

@@ -5,7 +5,6 @@ const blueprintsGroup: CliCommandGroupDefinition = {
   signature: '[COMMAND]',
   isGroupRoot: true,
   description: 'Deploy and manage Sanity Blueprints and Stacks (IaC)',
-  hideFromHelp: true,
 }
 
 export default blueprintsGroup

package/src/commands/blueprints/configBlueprintsCommand.ts

@@ -2,30 +2,51 @@ import {type CliCommandDefinition} from '../../types'
 
 const helpText = `
 Options
-  --edit  Edit the configuration
+  --edit, -e           Edit the configuration
+  --test, -t           Test the configuration
+  --project-id <id>    Project ID to use
 
-Examples
+Examples:
   # View current configuration
   sanity blueprints config
 
   # Edit configuration
   sanity blueprints config --edit
+
+  # Test configuration
+  sanity blueprints config --test
+
+  # Edit and test configuration
+  sanity blueprints config -et
 `
 
-const defaultFlags = {
-  edit: false,
+export interface BlueprintsConfigFlags {
+  'test-config'?: boolean
+  'test'?: boolean
+  't'?: boolean
+  'edit'?: boolean
+  'e'?: boolean
+  'project-id'?: string
+  'projectId'?: string
+  'project'?: string
+  'stack-id'?: string
+  'stackId'?: string
+  'stack'?: string
+}
+
+const defaultFlags: BlueprintsConfigFlags = {
+  //
 }
 
-const configBlueprintsCommand: CliCommandDefinition = {
+const configBlueprintsCommand: CliCommandDefinition<BlueprintsConfigFlags> = {
   name: 'config',
   group: 'blueprints',
   helpText,
-  signature: '[--edit]',
+  signature: '[--edit] [-e] [--test] [-t] [--project-id <id>]',
   description: 'View or edit local Blueprints configuration',
-  hideFromHelp: true,
+
   async action(args, context) {
-    const {apiClient, output, prompt} = context
-    const {print} = output
+    const {apiClient, output} = context
     const flags = {...defaultFlags, ...args.extOptions}
 
     const client = apiClient({
@@ -33,79 +54,34 @@ const configBlueprintsCommand: CliCommandDefinition = {
       requireProject: false,
     })
     const {token} = client.config()
-    const {
-      blueprint: blueprintAction,
-      projects: projectsAction,
-      stacks: stacksAction,
-    } = await import('@sanity/runtime-cli/actions/blueprints')
-
-    const config = blueprintAction.readConfigFile()
-    if (!config) {
-      print('No configuration found. Run `sanity blueprints init` first.')
-      return
-    }
 
-    print('\nCurrent configuration:')
-    print(JSON.stringify(config, null, 2))
-
-    if (!flags.edit) {
-      return
-    }
+    if (!token) throw new Error('No API token found. Please run `sanity login`.')
 
-    if (!token) {
-      print('No API token found. Please run `sanity login` first.')
-      return
-    }
+    const {blueprintConfigCore} = await import('@sanity/runtime-cli/cores/blueprints')
+    const {getBlueprintAndStack} = await import('@sanity/runtime-cli/actions/blueprints')
+    const {display} = await import('@sanity/runtime-cli/utils')
 
-    const {ok, projects, error} = await projectsAction.listProjects({token})
-    if (!ok) {
-      print(error)
-      return
-    }
+    const {localBlueprint, issues} = await getBlueprintAndStack({token})
 
-    if (!projects || projects.length === 0) {
-      print('No Projects found. Please create a Project in Sanity.io first.')
-      return
+    if (issues) {
+      // print issues and continue
+      output.print(display.errors.presentBlueprintIssues(issues))
     }
 
-    const projectChoices = projects.map(({displayName, id}) => ({
-      value: id,
-      name: `${displayName} <${id}>`,
-    }))
-
-    const projectId = await prompt.single({
-      type: 'list',
-      message: 'Select your Sanity Project:',
-      choices: projectChoices,
-      default: config.projectId,
+    const {success, error} = await blueprintConfigCore({
+      bin: 'sanity',
+      log: (message) => output.print(message),
+      blueprint: localBlueprint,
+      token,
+      flags: {
+        'project-id': flags['project-id'] ?? flags.projectId ?? flags.project,
+        'stack-id': flags['stack-id'] ?? flags.stackId ?? flags.stack,
+        'test-config': flags['test-config'] ?? flags.test ?? flags.t,
+        'edit': flags.edit ?? flags.e,
+      },
     })
 
-    const auth = {token, projectId}
-
-    // get stacks for selected project
-    const {ok: stacksOk, stacks, error: stacksError} = await stacksAction.listStacks(auth)
-    if (!stacksOk) {
-      print(stacksError)
-      return
-    }
-
-    let stackId
-    if (stacks && stacks.length > 0) {
-      const stackChoices = stacks.map(({name, id}) => ({
-        value: id,
-        name: `${name} <${id}>`,
-      }))
-
-      stackId = await prompt.single({
-        type: 'list',
-        message: 'Select a Stack:',
-        choices: stackChoices,
-        default: config.stackId,
-      })
-    }
-
-    blueprintAction.writeConfigFile({projectId, stackId})
-    print('\nConfiguration updated successfully.')
+    if (!success) throw new Error(error)
   },
 }