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

package/src/commands/functions/logsFunctionsCommand.ts

@@ -1,44 +1,49 @@
-import {type types} from '@sanity/runtime-cli/utils'
+import chalk from 'chalk'
+import inquirer from 'inquirer'
 
 import {type CliCommandDefinition} from '../../types'
 
-type StackFunctionResource = types.StackFunctionResource
-
 const helpText = `
+Arguments
+  <name> The name of the Function to retrieve logs for
+
 Options
-  --name <name> The name of the function to retrieve logs for
   --limit <limit> The number of log entries to retrieve [default 50]
   --json If set return json
   --utc Use UTC dates in logs
 
 Examples
-  # Retrieve logs for Sanity Function abcd1234
-  sanity functions logs --name echo
+  # Retrieve logs for Sanity Function
+  sanity functions logs echo
 
-  # Retrieve the last two log entries for Sanity Function abcd1234
-  sanity functions logs --name echo --limit 2
+  # Retrieve the last two log entries for Sanity Function
+  sanity functions logs echo --limit 2
 
-  # Retrieve logs for Sanity Function abcd1234 in json format
+  # Retrieve logs for Sanity Function in json format
   sanity functions logs --name echo --json
+
+  # Delete all logs for Sanity Function
+  sanity functions logs --name echo --delete
 `
 
 const defaultFlags = {
-  name: '',
   limit: 50,
   json: false,
   utc: false,
+  delete: false,
+  force: false,
 }
 
 const logsFunctionsCommand: CliCommandDefinition = {
   name: 'logs',
   group: 'functions',
   helpText,
-  signature: '',
-  description: 'Retrieve logs for a Sanity Function',
-  hideFromHelp: true,
+  signature: '<name> [--limit <number>] [--json] [--utc] [--delete [--force]]',
+  description: 'Retrieve or delete logs for a Sanity Function',
   async action(args, context) {
     const {apiClient, output} = context
-    const {print} = output
+    const {print, error: printError} = output
+    const [name] = args.argsWithoutOptions
     const flags = {...defaultFlags, ...args.extOptions}
 
     const client = apiClient({
@@ -46,69 +51,97 @@ const logsFunctionsCommand: CliCommandDefinition = {
       requireProject: false,
     })
 
-    if (flags.name === '') {
-      throw new Error('You must provide a function name via the --name flag')
+    if (!name) {
+      throw new Error('You must provide a function name as the first argument')
     }
 
     const token = client.config().token
-    const {blueprint} = await import('@sanity/runtime-cli/actions/blueprints')
+    if (!token) throw new Error('No API token found. Please run `sanity login`.')
+
+    const {getBlueprintAndStack} = await import('@sanity/runtime-cli/actions/blueprints')
     const {findFunction} = await import('@sanity/runtime-cli/utils')
 
-    const {deployedStack} = await blueprint.readBlueprintOnDisk({
-      getStack: true,
-      token,
-    })
+    const {deployedStack} = await getBlueprintAndStack({token})
 
     if (!deployedStack) {
       throw new Error('Stack not found')
     }
 
-    const blueprintConfig = blueprint.readConfigFile()
-    const projectId = blueprintConfig?.projectId
+    const {projectId} = deployedStack
 
-    const {externalId} = findFunction.findFunctionByName(
-      deployedStack,
-      flags.name,
-    ) as StackFunctionResource
+    const {externalId} = findFunction.findFunctionByName(deployedStack, name)
 
     if (token && projectId) {
       const {logs: logsAction} = await import('@sanity/runtime-cli/actions/functions')
-      const {ok, error, logs, total} = await logsAction.logs(
-        externalId,
-        {limit: flags.limit},
-        {token, projectId},
-      )
-
-      if (!ok) {
-        print(`Error: ${error || 'Unknown error'}`)
-        return
-      }
 
-      const filteredLogs = logs.filter(
-        (entry: {level: string; message: string}) => entry.level && entry.message,
-      )
+      if (!externalId) throw new Error('Unable to delete logs. Unable to determine function ID.')
+
+      if (flags.delete) {
+        if (!flags.force) {
+          const {certain} = await inquirer.prompt({
+            type: 'confirm',
+            name: 'certain',
+            message: `Are you sure you want to delete ${chalk.bold('all')} logs for function ${chalk.yellow(name)}?`,
+            default: false,
+          })
+          if (!certain) return
+        }
 
-      if (filteredLogs.length === 0) {
-        print(`No logs found for function ${flags.name}`)
-        return
-      }
+        print(`Deleting logs for function ${chalk.yellow(name)}`)
+        const {ok, error} = await logsAction.deleteLogs(externalId, {token, projectId})
 
-      if (flags.json) {
-        print(JSON.stringify(filteredLogs, null, 2))
+        if (!ok) {
+          printError(`${chalk.red('Failed')} to retrieve logs`)
+          printError(`Error: ${error || 'Unknown error'}`)
+          return
+        }
+
+        print('Logs deleted')
       } else {
-        print(`Found ${total} log entries for function ${flags.name}`)
-        if (logs.length < total) {
-          print(`Here are the last ${filteredLogs.length} entries`)
+        print(`Finding logs for function "${name}"`)
+
+        const {ok, error, logs, total} = await logsAction.logs(
+          externalId,
+          {limit: flags.limit},
+          {token, projectId},
+        )
+
+        if (!ok) {
+          printError(`${chalk.red('Failed')} to retrieve logs`)
+          printError(`Error: ${error || 'Unknown error'}`)
+          return
+        }
+
+        const filteredLogs = logs.filter(
+          (entry: {level: string; message: string}) => entry.level && entry.message,
+        )
+
+        if (filteredLogs.length === 0) {
+          print(`No logs found for function ${name}`)
+          return
         }
-        print('\n')
-
-        for (const log of filteredLogs) {
-          const {time, level, message} = log
-          const date = new Date(time)
-          const dateString = flags.utc
-            ? date.toISOString().slice(0, 19).split('T').join(' ')
-            : `${date.toLocaleDateString()} ${date.toLocaleTimeString()}`
-          print(`${dateString} ${level} ${message}`)
+
+        if (flags.json) {
+          print(JSON.stringify(filteredLogs, null, 2))
+        } else {
+          print(`Found ${total} log entries for function ${name}`)
+          if (logs.length < total) {
+            print(`Here are the last ${filteredLogs.length} entries`)
+          }
+          print('\n')
+
+          for (const log of filteredLogs) {
+            const {time, level, message} = log
+            const date = new Date(time)
+            const [dateString, timeString] = flags.utc
+              ? date.toISOString().slice(0, 19).split('T')
+              : [date.toLocaleDateString(), date.toLocaleTimeString()]
+            print(
+              [chalk.bold(dateString), chalk.bold.blue(timeString), logLevel(level), message].join(
+                ' ',
+              ),
+            )
+          }
         }
       }
     } else {
@@ -117,4 +150,14 @@ const logsFunctionsCommand: CliCommandDefinition = {
   },
 }
 
+function logLevel(level: string) {
+  if (level === 'ERROR') {
+    return chalk.red(level)
+  }
+  if (level === 'WARN') {
+    return chalk.yellow(level)
+  }
+  return chalk.green(level)
+}
+
 export default logsFunctionsCommand

package/src/commands/functions/testFunctionsCommand.ts

@@ -1,76 +1,96 @@
 import {type CliCommandDefinition} from '../../types'
 
 const helpText = `
+Arguments
+  <name> The name of the Sanity Function
+
 Options
   --data <data> Data to send to the function
   --file <file> Read data from file and send to the function
-  --name <name> The name of your Sanity Function
   --timeout <timeout> Execution timeout value in seconds
+  --api <version> Sanity API Version to use
+  --dataset <dataset> The Sanity dataset to use
+  --project-id <id> Sanity Project ID to use
+
 
 Examples
   # Test function passing event data on command line
-  sanity functions test --name echo --data '{ "id": 1 }'
+  sanity functions test echo --data '{ "id": 1 }'
 
   # Test function passing event data via a file
-  sanity functions test -name echo --file 'payload.json'
+  sanity functions test echo --file 'payload.json'
 
   # Test function passing event data on command line and cap execution time to 60 seconds
-  sanity functions test -name echo --data '{ "id": 1 }' --timeout 60
+  sanity functions test echo --data '{ "id": 1 }' --timeout 60
 `
 
 const defaultFlags = {
-  data: undefined,
-  file: undefined,
-  name: '',
-  timeout: 5, // seconds
+  'data': undefined,
+  'file': undefined,
+  'timeout': 10, // seconds
+  'api': undefined,
+  'dataset': undefined,
+  'project-id': undefined,
+  'project': undefined,
+  'projectId': undefined,
 }
 
 const testFunctionsCommand: CliCommandDefinition = {
   name: 'test',
   group: 'functions',
   helpText,
-  signature: '',
+  signature:
+    '<name> [--data <json>] [--file <filename>] [--timeout <seconds>] [--api <version>] [--dataset <name>] [--project-id] <id>]',
   description: 'Invoke a local Sanity Function',
-  hideFromHelp: true,
   async action(args, context) {
     const {output} = context
-    const {print} = output
+    const {print, error: printError} = output
+    const [name] = args.argsWithoutOptions
     const flags = {...defaultFlags, ...args.extOptions}
 
-    if (flags.name === '') {
-      throw new Error('You must provide a function name via the --name flag')
+    if (!name) {
+      throw new Error('You must provide a function name as the first argument')
     }
 
     const {test} = await import('@sanity/runtime-cli/actions/functions')
     const {blueprint} = await import('@sanity/runtime-cli/actions/blueprints')
     const {findFunction} = await import('@sanity/runtime-cli/utils')
 
-    const {parsedBlueprint} = await blueprint.readBlueprintOnDisk({
-      getStack: false,
-    })
+    const {parsedBlueprint} = await blueprint.readLocalBlueprint()
 
-    const src = findFunction.getFunctionSource(parsedBlueprint, flags.name)
-    if (!src) {
-      throw new Error(`Error: Function ${flags.name} has no source code`)
-    }
+    try {
+      const fn = findFunction.findFunctionByName(parsedBlueprint, name)
+      if (!fn) {
+        throw new Error(`Function ${name} has no source code`)
+      }
 
-    const {json, logs, error} = await test.testAction(
-      src,
-      {
-        data: flags.data,
-        file: flags.file,
-        timeout: flags.timeout,
-      },
-      {}, // @TODO: Add context
-    )
+      const projectId = flags['project-id'] ?? flags.projectId ?? flags.project
+      const {json, logs, error} = await test.testAction(
+        fn,
+        {
+          data: flags.data,
+          file: flags.file,
+          timeout: flags.timeout,
+        },
+        {
+          clientOptions: {
+            apiVersion: flags.api,
+            dataset: flags.dataset,
+            projectId: projectId,
+          },
+        },
+      )
 
-    if (error) {
-      print(error.toString())
-    } else {
-      print('Logs:')
-      print(logs)
-      print('Response:')
-      print(JSON.stringify(json, null, 2))
+      if (error) {
+        print(error.toString())
+      } else {
+        print('Logs:')
+        print(logs)
+        print('Response:')
+        print(JSON.stringify(json, null, 2))
+      }
+    } catch (error) {
+      printError(`Error: ${error || 'Unknown error'}`)
     }
   },
 }

package/src/commands/index.ts

@@ -3,6 +3,7 @@ import addBlueprintsCommand from './blueprints/addBlueprintsCommand'
 import blueprintsGroup from './blueprints/blueprintsGroup'
 import configBlueprintsCommand from './blueprints/configBlueprintsCommand'
 import deployBlueprintsCommand from './blueprints/deployBlueprintsCommand'
+import destroyBlueprintsCommand from './blueprints/destroyBlueprintsCommand'
 import infoBlueprintsCommand from './blueprints/infoBlueprintsCommand'
 import initBlueprintsCommand from './blueprints/initBlueprintsCommand'
 import logsBlueprintsCommand from './blueprints/logsBlueprintsCommand'
@@ -59,12 +60,13 @@ export const baseCommands: (CliCommandDefinition | CliCommandGroupDefinition)[]
   testfunctionsCommand,
   envFunctionsCommand,
   blueprintsGroup,
+  addBlueprintsCommand,
+  configBlueprintsCommand,
+  deployBlueprintsCommand,
+  destroyBlueprintsCommand,
   infoBlueprintsCommand,
-  listBlueprintsCommand,
   initBlueprintsCommand,
-  deployBlueprintsCommand,
+  listBlueprintsCommand,
   logsBlueprintsCommand,
-  addBlueprintsCommand,
-  configBlueprintsCommand,
   planBlueprintsCommand,
 ]

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