@sanity/cli 3.86.1 → 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/util/__tests__/workerChannel.test.ts

@@ -0,0 +1,222 @@
+import {EventEmitter} from 'node:events'
+import {type MessagePort, type Worker} from 'node:worker_threads'
+
+import {afterEach, beforeEach, describe, expect, it, vi} from 'vitest'
+
+import {
+  createReceiver,
+  createReporter,
+  type WorkerChannel,
+  type WorkerChannelEvent,
+  type WorkerChannelStream,
+} from '../workerChannel'
+
+// Define a sample worker channel for testing
+type TestWorkerChannel = WorkerChannel<{
+  simpleEvent: WorkerChannelEvent<string>
+  dataEvent: WorkerChannelEvent<{id: number; value: boolean}>
+  simpleStream: WorkerChannelStream<number>
+  endStream: WorkerChannelStream<void>
+}>
+
+// Mock Worker and MessagePort
+class MockWorker extends EventEmitter {
+  terminated = false
+  terminate = vi.fn(async () => {
+    this.terminated = true
+    return 0
+  })
+  postMessage = vi.fn((message: unknown) => {
+    this.emit('message', message)
+  })
+
+  // Helper to simulate receiving a message from the parent (if needed)
+  receiveMessage(message: unknown) {
+    this.emit('message', message)
+  }
+
+  // Helper to simulate an error from the worker
+  emitError(error: unknown) {
+    this.emit('error', error)
+  }
+}
+
+class MockMessagePort extends EventEmitter {
+  postMessage = vi.fn((message: unknown) => {
+    // Simulate the message being sent back to the parent/receiver
+    // In a real scenario, this would go to the Worker's listener
+    mockWorkerInstance?.receiveMessage(message)
+  })
+
+  // Helper to simulate receiving a message (e.g., from the parent)
+  receiveMessage(message: unknown) {
+    this.emit('message', message)
+  }
+}
+
+let mockWorkerInstance: MockWorker
+let mockParentPortInstance: MockMessagePort
+let receiver: ReturnType<typeof createReceiver<TestWorkerChannel>>
+let reporter: ReturnType<typeof createReporter<TestWorkerChannel>>
+
+beforeEach(() => {
+  mockWorkerInstance = new MockWorker()
+  mockParentPortInstance = new MockMessagePort()
+  receiver = createReceiver<TestWorkerChannel>(mockWorkerInstance as unknown as Worker)
+  reporter = createReporter<TestWorkerChannel>(mockParentPortInstance as unknown as MessagePort)
+})
+
+afterEach(() => {
+  vi.clearAllMocks()
+})
+
+describe('workerChannel', () => {
+  it('should send and receive a simple event', async () => {
+    const receivedPromise = receiver.event.simpleEvent()
+    reporter.event.simpleEvent('hello')
+
+    await expect(receivedPromise).resolves.toBe('hello')
+  })
+
+  it('should send and receive an event with data object', async () => {
+    const payload = {id: 123, value: true}
+    const receivedPromise = receiver.event.dataEvent()
+    reporter.event.dataEvent(payload)
+
+    await expect(receivedPromise).resolves.toEqual(payload)
+  })
+
+  it('should send and receive a stream of data', async () => {
+    const receivedItems: number[] = []
+    const streamPromise = (async () => {
+      for await (const item of receiver.stream.simpleStream()) {
+        receivedItems.push(item)
+      }
+    })()
+
+    reporter.stream.simpleStream.emit(1)
+    reporter.stream.simpleStream.emit(2)
+    reporter.stream.simpleStream.emit(3)
+    reporter.stream.simpleStream.end()
+
+    await streamPromise // Wait for the stream processing to complete
+
+    expect(receivedItems).toEqual([1, 2, 3])
+  })
+
+  it('should handle an empty stream correctly', async () => {
+    let streamEntered = false
+    const streamPromise = (async () => {
+      for await (const _item of receiver.stream.endStream()) {
+        streamEntered = true // This should not happen
+      }
+    })()
+
+    reporter.stream.endStream.end() // End immediately
+
+    await streamPromise
+
+    expect(streamEntered).toBe(false)
+  })
+
+  it('should propagate errors from the worker via event receiver', async () => {
+    const error = new Error('Worker failed')
+
+    const receivedPromise = receiver.event.simpleEvent()
+    mockWorkerInstance?.emitError(error)
+
+    await expect(receivedPromise).rejects.toThrow(error)
+  })
+
+  it('should propagate errors from the worker via stream receiver', async () => {
+    const error = new Error('Worker failed during stream')
+
+    const streamPromise = (async () => {
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      for await (const _item of receiver.stream.simpleStream()) {
+        // no-op
+      }
+    })()
+
+    // Emit error before ending the stream
+    mockWorkerInstance?.emitError(error)
+
+    await expect(streamPromise).rejects.toThrow(error)
+  })
+
+  it('should handle messages arriving before receiver awaits', async () => {
+    // Reporter sends event *before* receiver awaits it
+    reporter.event.simpleEvent('early bird')
+
+    // Give a tick for the message to be processed internally by the mock
+    await new Promise((resolve) => setImmediate(resolve))
+
+    const receivedPromise = receiver.event.simpleEvent()
+
+    await expect(receivedPromise).resolves.toBe('early bird')
+  })
+
+  it('should handle stream emissions arriving before receiver iterates', async () => {
+    // Reporter sends stream data *before* receiver starts iterating
+    reporter.stream.simpleStream.emit(10)
+    reporter.stream.simpleStream.emit(20)
+
+    // Give a tick for messages to process
+    await new Promise((resolve) => setImmediate(resolve))
+
+    const receivedItems: number[] = []
+    const streamPromise = (async () => {
+      for await (const item of receiver.stream.simpleStream()) {
+        receivedItems.push(item)
+      }
+    })()
+
+    // Send remaining data and end
+    reporter.stream.simpleStream.emit(30)
+    reporter.stream.simpleStream.end()
+
+    await streamPromise
+
+    expect(receivedItems).toEqual([10, 20, 30])
+  })
+
+  it('dispose() should remove listeners and terminate worker', async () => {
+    expect(mockWorkerInstance?.listenerCount('message')).toBe(1)
+    expect(mockWorkerInstance?.listenerCount('error')).toBe(1)
+
+    const terminatePromise = receiver.dispose()
+
+    await expect(terminatePromise).resolves.toBe(0)
+    expect(mockWorkerInstance?.terminate).toHaveBeenCalledTimes(1)
+    expect(mockWorkerInstance?.listenerCount('message')).toBe(0)
+    expect(mockWorkerInstance?.listenerCount('error')).toBe(0)
+    expect(mockWorkerInstance?.terminated).toBe(true)
+  })
+
+  it('should throw error if parentPort is null for reporter', () => {
+    expect(() => createReporter<TestWorkerChannel>(null)).toThrow('parentPart was falsy')
+  })
+
+  it('should ignore non-worker channel messages', async () => {
+    const receivedPromise = receiver.event.simpleEvent()
+
+    // Send a valid message
+    reporter.event.simpleEvent('valid')
+    await expect(receivedPromise).resolves.toBe('valid')
+
+    const nextReceivedPromise = receiver.event.simpleEvent()
+
+    // Send an invalid message
+    mockWorkerInstance?.receiveMessage({foo: 'bar'}) // Not a valid WorkerChannelMessage
+    mockWorkerInstance?.receiveMessage('just a string')
+    mockWorkerInstance?.receiveMessage(null)
+    mockWorkerInstance?.receiveMessage(undefined)
+    mockWorkerInstance?.receiveMessage({type: 'unknown'})
+
+    // Send the actual message we are waiting for
+    reporter.event.simpleEvent('after invalid')
+
+    // It should eventually resolve with the correct message, ignoring the invalid ones
+    await expect(nextReceivedPromise).resolves.toBe('after invalid')
+  })
+})

package/src/util/journeyConfig.ts

@@ -7,7 +7,6 @@ import {
   type DocumentDefinition,
   type ObjectDefinition,
 } from '@sanity/types'
-import {format} from 'prettier'
 
 import {type CliApiClient} from '../types'
 import {getCliWorkerPath} from './cliWorker'
@@ -184,6 +183,7 @@ 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,11 +198,12 @@ async function assembleJourneySchemaTypeFileContent(schemaType: DocumentOrObject
  * @param schemas - The Journey schemas to assemble into an index file
  * @returns The index file as a string
  */
-function assembleJourneyIndexContent(schemas: DocumentOrObject[]): Promise<string> {
+async 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'})
 }