@sanity/cli 3.86.0 → 3.86.2-experimental.0

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'})
 }
 

package/src/util/workerChannel.ts

@@ -0,0 +1,312 @@
+// NOTE: this file was originally copied from
+// https://github.com/sanity-io/sanity/blob/4c4e03d407106dbda12f52cfd9511fbfe75a9696/packages/sanity/src/_internal/cli/util/workerChannels.ts
+import {type MessagePort, type Worker} from 'node:worker_threads'
+
+type StreamReporter<TPayload = unknown> = {emit: (payload: TPayload) => void; end: () => void}
+type EventReporter<TPayload = unknown> = (payload: TPayload) => void
+type EventReceiver<TPayload = unknown> = () => Promise<TPayload>
+type StreamReceiver<TPayload = unknown> = () => AsyncIterable<TPayload>
+
+type EventKeys<TWorkerChannel extends WorkerChannel> = {
+  [K in keyof TWorkerChannel]: TWorkerChannel[K] extends WorkerChannelEvent<any> ? K : never
+}[keyof TWorkerChannel]
+type StreamKeys<TWorkerChannel extends WorkerChannel> = {
+  [K in keyof TWorkerChannel]: TWorkerChannel[K] extends WorkerChannelStream<any> ? K : never
+}[keyof TWorkerChannel]
+
+type EventMessage<TPayload = unknown> = {type: 'event'; name: string; payload: TPayload}
+type StreamEmissionMessage<TPayload = unknown> = {type: 'emission'; name: string; payload: TPayload}
+type StreamEndMessage = {type: 'end'; name: string}
+type WorkerChannelMessage = EventMessage | StreamEmissionMessage | StreamEndMessage
+
+/**
+ * Represents the definition of a "worker channel" to report progress from the
+ * worker to the parent. Worker channels can define named events or streams and
+ * the worker will report events and streams while the parent will await them.
+ * This allows the control flow of the parent to follow the control flow of the
+ * worker 1-to-1.
+ *
+ * @example
+ *
+ * ```ts
+ * // Define the channel interface (shared between parent and worker)
+ * type MyWorkerChannel = WorkerChannel<{
+ *   compileStart: WorkerChannelEvent<void>
+ *   compileProgress: WorkerChannelStream<{ file: string; progress: number }>
+ *   compileEnd: WorkerChannelEvent<{ duration: number }>
+ * }>;
+ *
+ * // --- In the worker file (e.g., worker.ts) ---
+ * import { parentPort } from 'node:worker_threads';
+ * import { createReporter } from './workerChannels';
+ *
+ * const report = createReporter<MyWorkerChannel>(parentPort);
+ *
+ * async function runCompilation() {
+ *   report.event.compileStart(); // Signal start
+ *
+ *   const files = ['a.js', 'b.js', 'c.js'];
+ *   for (const file of files) {
+ *     // Simulate work and report progress
+ *     await new Promise(resolve => setTimeout(resolve, 100));
+ *     report.stream.compileProgress.emit({ file, progress: 100 });
+ *   }
+ *   report.stream.compileProgress.end(); // Signal end of progress stream
+ *
+ *   report.event.compileEnd({ duration: 300 }); // Signal end with result
+ * }
+ *
+ * runCompilation();
+ *
+ * // --- In the parent file (e.g., main.ts) ---
+ * import { Worker } from 'node:worker_threads';
+ * import { createReceiver } from './workerChannels';
+ *
+ * const worker = new Worker('./worker.js');
+ * const receiver = createReceiver<MyWorkerChannel>(worker);
+ *
+ * async function monitorCompilation() {
+ *   console.log('Waiting for compilation to start...');
+ *   await receiver.event.compileStart();
+ *   console.log('Compilation started.');
+ *
+ *   console.log('Receiving progress:');
+ *   for await (const progress of receiver.stream.compileProgress()) {
+ *     console.log(`  - ${progress.file}: ${progress.progress}%`);
+ *   }
+ *
+ *   console.log('Waiting for compilation to end...');
+ *   const { duration } = await receiver.event.compileEnd();
+ *   console.log(`Compilation finished in ${duration}ms.`);
+ *
+ *   await receiver.dispose(); // Clean up listeners and terminate worker
+ * }
+ *
+ * monitorCompilation();
+ * ```
+ *
+ * @internal
+ */
+export type WorkerChannel<
+  TWorkerChannel extends Record<
+    string,
+    WorkerChannelEvent<unknown> | WorkerChannelStream<unknown>
+  > = Record<string, WorkerChannelEvent<unknown> | WorkerChannelStream<unknown>>,
+> = TWorkerChannel
+
+/** @internal */
+export type WorkerChannelEvent<TPayload = void> = {type: 'event'; payload: TPayload}
+/** @internal */
+export type WorkerChannelStream<TPayload = void> = {type: 'stream'; payload: TPayload}
+
+export interface WorkerChannelReporter<TWorkerChannel extends WorkerChannel> {
+  event: {
+    [K in EventKeys<TWorkerChannel>]: TWorkerChannel[K] extends WorkerChannelEvent<infer TPayload>
+      ? EventReporter<TPayload>
+      : void
+  }
+  stream: {
+    [K in StreamKeys<TWorkerChannel>]: TWorkerChannel[K] extends WorkerChannelStream<infer TPayload>
+      ? StreamReporter<TPayload>
+      : void
+  }
+}
+
+export interface WorkerChannelReceiver<TWorkerChannel extends WorkerChannel> {
+  event: {
+    [K in EventKeys<TWorkerChannel>]: TWorkerChannel[K] extends WorkerChannelEvent<infer TPayload>
+      ? EventReceiver<TPayload>
+      : void
+  }
+  stream: {
+    [K in StreamKeys<TWorkerChannel>]: TWorkerChannel[K] extends WorkerChannelStream<infer TPayload>
+      ? StreamReceiver<TPayload>
+      : void
+  }
+  // TODO: good candidate for [Symbol.asyncDispose] when our tooling better supports it
+  dispose: () => Promise<number>
+}
+
+/**
+ * A simple queue that has two primary methods: `push(message)` and
+ * `await next()`. This message queue is used by the "receiver" of the worker
+ * channel and this class handles buffering incoming messages if the worker is
+ * producing faster than the parent as well as returning a promise if there is
+ * no message yet in the queue when the parent awaits `next()`.
+ */
+class MessageQueue<T> {
+  resolver: ((result: IteratorResult<T>) => void) | null = null
+  queue: T[] = []
+  private ended = false // Flag to indicate if end() was called
+
+  push(message: T) {
+    if (this.ended) {
+      // Don't push messages after the queue has ended
+      return
+    }
+    if (this.resolver) {
+      this.resolver({value: message, done: false})
+      this.resolver = null
+    } else {
+      this.queue.push(message)
+    }
+  }
+
+  next(): Promise<IteratorResult<T>> {
+    if (this.queue.length) {
+      return Promise.resolve({value: this.queue.shift()!, done: false})
+    }
+
+    if (this.ended) {
+      // If end() was called before and queue is empty, resolve immediately as done
+      return Promise.resolve({value: undefined, done: true})
+    }
+
+    return new Promise((resolve) => (this.resolver = resolve))
+  }
+
+  end() {
+    if (this.resolver) {
+      this.resolver({value: undefined, done: true})
+      this.resolver = null // Clear resolver after ending
+    } else {
+      // If resolver is null, it means next() hasn't been called yet or
+      // previous next() was resolved by a push(). Mark as ended so the
+      // *next* call to next() resolves immediately as done.
+      this.ended = true
+    }
+  }
+}
+
+function isWorkerChannelMessage(message: unknown): message is WorkerChannelMessage {
+  if (typeof message !== 'object') return false
+  if (!message) return false
+  if (!('type' in message)) return false
+  if (typeof message.type !== 'string') return false
+  const types: string[] = ['event', 'emission', 'end'] satisfies WorkerChannelMessage['type'][]
+  return types.includes(message.type)
+}
+
+/**
+ * Creates a "worker channel receiver" that subscribes to incoming messages
+ * from the given worker and returns promises for worker channel events and
+ * async iterators for worker channel streams.
+ */
+export function createReceiver<TWorkerChannel extends WorkerChannel>(
+  worker: Worker,
+): WorkerChannelReceiver<TWorkerChannel> {
+  const _events = new Map<string, MessageQueue<EventMessage>>()
+  const _streams = new Map<string, MessageQueue<StreamEmissionMessage>>()
+  const errors = new MessageQueue<{type: 'error'; error: unknown}>()
+
+  const eventQueue = (name: string) => {
+    const queue = _events.get(name) ?? new MessageQueue()
+    if (!_events.has(name)) _events.set(name, queue)
+    return queue
+  }
+
+  const streamQueue = (name: string) => {
+    const queue = _streams.get(name) ?? new MessageQueue()
+    if (!_streams.has(name)) _streams.set(name, queue)
+    return queue
+  }
+
+  const handleMessage = (message: unknown) => {
+    if (!isWorkerChannelMessage(message)) return
+    if (message.type === 'event') eventQueue(message.name).push(message)
+    if (message.type === 'emission') streamQueue(message.name).push(message)
+    if (message.type === 'end') streamQueue(message.name).end()
+  }
+
+  const handleError = (error: unknown) => {
+    errors.push({type: 'error', error})
+  }
+
+  worker.addListener('message', handleMessage)
+  worker.addListener('error', handleError)
+
+  return {
+    event: new Proxy({} as WorkerChannelReceiver<TWorkerChannel>['event'], {
+      get: (target, name) => {
+        if (typeof name !== 'string') return target[name as keyof typeof target]
+
+        const eventReceiver: EventReceiver = async () => {
+          const {value} = await Promise.race([eventQueue(name).next(), errors.next()])
+          if (value.type === 'error') throw value.error
+          return value.payload
+        }
+
+        return eventReceiver
+      },
+    }),
+    stream: new Proxy({} as WorkerChannelReceiver<TWorkerChannel>['stream'], {
+      get: (target, prop) => {
+        if (typeof prop !== 'string') return target[prop as keyof typeof target]
+        const name = prop // alias for better typescript narrowing
+
+        async function* streamReceiver() {
+          while (true) {
+            const {value, done} = await Promise.race([streamQueue(name).next(), errors.next()])
+            if (done) return
+            if (value.type === 'error') throw value.error
+            yield value.payload
+          }
+        }
+
+        return streamReceiver satisfies StreamReceiver
+      },
+    }),
+    dispose: () => {
+      worker.removeListener('message', handleMessage)
+      worker.removeListener('error', handleError)
+      return worker.terminate()
+    },
+  }
+}
+
+/**
+ * Creates a "worker channel reporter" that sends messages to the given
+ * `parentPort` to be received by a worker channel receiver.
+ *
+ * @internal
+ */
+export function createReporter<TWorkerChannel extends WorkerChannel>(
+  parentPort: MessagePort | null,
+): WorkerChannelReporter<TWorkerChannel> {
+  if (!parentPort) {
+    throw new Error('parentPart was falsy')
+  }
+
+  return {
+    event: new Proxy({} as WorkerChannelReporter<TWorkerChannel>['event'], {
+      get: (target, name) => {
+        if (typeof name !== 'string') return target[name as keyof typeof target]
+
+        const eventReporter: EventReporter = (payload) => {
+          const message: EventMessage = {type: 'event', name, payload}
+          parentPort.postMessage(message)
+        }
+
+        return eventReporter
+      },
+    }),
+    stream: new Proxy({} as WorkerChannelReporter<TWorkerChannel>['stream'], {
+      get: (target, name) => {
+        if (typeof name !== 'string') return target[name as keyof typeof target]
+
+        const streamReporter: StreamReporter = {
+          emit: (payload) => {
+            const message: StreamEmissionMessage = {type: 'emission', name, payload}
+            parentPort.postMessage(message)
+          },
+          end: () => {
+            const message: StreamEndMessage = {type: 'end', name}
+            parentPort.postMessage(message)
+          },
+        }
+
+        return streamReporter
+      },
+    }),
+  }
+}