@sanity/cli 3.86.1 → 3.86.2-experimental.0

package/lib/_chunks-cjs/workerChannel.js

@@ -0,0 +1,84 @@
+"use strict";
+class MessageQueue {
+  resolver = null;
+  queue = [];
+  ended = !1;
+  // Flag to indicate if end() was called
+  push(message) {
+    this.ended || (this.resolver ? (this.resolver({ value: message, done: !1 }), this.resolver = null) : this.queue.push(message));
+  }
+  next() {
+    return this.queue.length ? Promise.resolve({ value: this.queue.shift(), done: !1 }) : this.ended ? Promise.resolve({ value: void 0, done: !0 }) : new Promise((resolve) => this.resolver = resolve);
+  }
+  end() {
+    this.resolver ? (this.resolver({ value: void 0, done: !0 }), this.resolver = null) : this.ended = !0;
+  }
+}
+function isWorkerChannelMessage(message) {
+  return typeof message != "object" || !message || !("type" in message) || typeof message.type != "string" ? !1 : ["event", "emission", "end"].includes(message.type);
+}
+function createReceiver(worker) {
+  const _events = /* @__PURE__ */ new Map(), _streams = /* @__PURE__ */ new Map(), errors = new MessageQueue(), eventQueue = (name) => {
+    const queue = _events.get(name) ?? new MessageQueue();
+    return _events.has(name) || _events.set(name, queue), queue;
+  }, streamQueue = (name) => {
+    const queue = _streams.get(name) ?? new MessageQueue();
+    return _streams.has(name) || _streams.set(name, queue), queue;
+  }, handleMessage = (message) => {
+    isWorkerChannelMessage(message) && (message.type === "event" && eventQueue(message.name).push(message), message.type === "emission" && streamQueue(message.name).push(message), message.type === "end" && streamQueue(message.name).end());
+  }, handleError = (error) => {
+    errors.push({ type: "error", error });
+  };
+  return worker.addListener("message", handleMessage), worker.addListener("error", handleError), {
+    event: new Proxy({}, {
+      get: (target, name) => typeof name != "string" ? target[name] : async () => {
+        const { value } = await Promise.race([eventQueue(name).next(), errors.next()]);
+        if (value.type === "error") throw value.error;
+        return value.payload;
+      }
+    }),
+    stream: new Proxy({}, {
+      get: (target, prop) => {
+        if (typeof prop != "string") return target[prop];
+        const name = prop;
+        async function* streamReceiver() {
+          for (; ; ) {
+            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;
+      }
+    }),
+    dispose: () => (worker.removeListener("message", handleMessage), worker.removeListener("error", handleError), worker.terminate())
+  };
+}
+function createReporter(parentPort) {
+  if (!parentPort)
+    throw new Error("parentPart was falsy");
+  return {
+    event: new Proxy({}, {
+      get: (target, name) => typeof name != "string" ? target[name] : (payload) => {
+        const message = { type: "event", name, payload };
+        parentPort.postMessage(message);
+      }
+    }),
+    stream: new Proxy({}, {
+      get: (target, name) => typeof name != "string" ? target[name] : {
+        emit: (payload) => {
+          const message = { type: "emission", name, payload };
+          parentPort.postMessage(message);
+        },
+        end: () => {
+          const message = { type: "end", name };
+          parentPort.postMessage(message);
+        }
+      }
+    })
+  };
+}
+exports.createReceiver = createReceiver;
+exports.createReporter = createReporter;
+//# sourceMappingURL=workerChannel.js.map

package/lib/_chunks-cjs/workerChannel.js.map

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

package/lib/workers/typegenGenerate.d.ts

@@ -1,43 +1,111 @@
+import {GeneratedQueries} from '@sanity/codegen'
+import {GeneratedSchema} from '@sanity/codegen'
+import {GeneratedTypemap} from '@sanity/codegen'
+
 export declare interface TypegenGenerateTypesWorkerData {
   workDir: string
-  workspaceName?: string
-  schemaPath: string
+  schemas: {
+    projectId: string | 'default'
+    dataset: string | 'default'
+    schemaPath: string
+  }[]
   searchPath: string | string[]
-  overloadClientMethods?: boolean
+  overloadClientMethods: boolean
+  augmentGroqModule: boolean
+}
+
+/** @internal */
+export declare type TypegenWorkerChannel = WorkerChannel<{
+  schema: WorkerChannelEvent<GeneratedSchema>
+  queries: WorkerChannelStream<GeneratedQueries>
+  typemap: WorkerChannelEvent<GeneratedTypemap>
+}>
+
+/**
+ * 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
+ */
+declare type WorkerChannel<
+  TWorkerChannel extends Record<
+    string,
+    WorkerChannelEvent<unknown> | WorkerChannelStream<unknown>
+  > = Record<string, WorkerChannelEvent<unknown> | WorkerChannelStream<unknown>>,
+> = TWorkerChannel
+
+/** @internal */
+declare type WorkerChannelEvent<TPayload = void> = {
+  type: 'event'
+  payload: TPayload
 }
 
-export declare type TypegenGenerateTypesWorkerMessage =
-  | {
-      type: 'error'
-      error: Error
-      fatal: boolean
-      query?: string
-      filename?: string
-    }
-  | {
-      type: 'types'
-      filename: string
-      types: {
-        queryName: string
-        query: string
-        type: string
-        unknownTypeNodesGenerated: number
-        typeNodesGenerated: number
-        emptyUnionTypeNodesGenerated: number
-      }[]
-    }
-  | {
-      type: 'schema'
-      filename: string
-      schema: string
-      length: number
-    }
-  | {
-      type: 'typemap'
-      typeMap: string
-    }
-  | {
-      type: 'complete'
-    }
+/** @internal */
+declare type WorkerChannelStream<TPayload = void> = {
+  type: 'stream'
+  payload: TPayload
+}
 
 export {}

package/lib/workers/typegenGenerate.js

@@ -1,124 +1,37 @@
 "use strict";
-var node_worker_threads = require("node:worker_threads"), codegen = require("@sanity/codegen"), createDebug = require("debug"), groqJs = require("groq-js");
+var node_worker_threads = require("node:worker_threads"), codegen = require("@sanity/codegen"), debugIt = require("debug"), workerChannel = require("../_chunks-cjs/workerChannel.js");
 function _interopDefaultCompat(e) {
   return e && typeof e == "object" && "default" in e ? e : { default: e };
 }
-var createDebug__default = /* @__PURE__ */ _interopDefaultCompat(createDebug);
-const $info = createDebug__default.default("sanity:codegen:generate:info");
-createDebug__default.default("sanity:codegen:generate:warn");
+var debugIt__default = /* @__PURE__ */ _interopDefaultCompat(debugIt);
+const $info = debugIt__default.default("sanity:codegen:generate:info");
 if (node_worker_threads.isMainThread || !node_worker_threads.parentPort)
   throw new Error("This module must be run as a worker thread");
-const opts = node_worker_threads.workerData;
-codegen.registerBabel();
+const report = workerChannel.createReporter(node_worker_threads.parentPort), opts = node_worker_threads.workerData;
 async function main() {
-  const schema = await codegen.readSchema(opts.schemaPath), typeGenerator = new codegen.TypeGenerator(schema), schemaTypes = [typeGenerator.generateSchemaTypes(), codegen.TypeGenerator.generateKnownTypes()].join(`
-`).trim(), resolver = codegen.getResolver();
-  node_worker_threads.parentPort?.postMessage({
-    type: "schema",
-    schema: `${schemaTypes.trim()}
-`,
-    filename: "schema.json",
-    length: schema.length
-  });
-  const queries = codegen.findQueriesInPath({
-    path: opts.searchPath,
-    resolver
-  }), allQueries = [];
-  for await (const result of queries) {
-    if (result.type === "error") {
-      node_worker_threads.parentPort?.postMessage({
-        type: "error",
-        error: result.error,
-        fatal: !1,
-        filename: result.filename
-      });
-      continue;
-    }
-    $info(`Processing ${result.queries.length} queries in "${result.filename}"...`);
-    const fileQueryTypes = [];
-    for (const { name: queryName, result: query } of result.queries)
-      try {
-        const ast = codegen.safeParseQuery(query), queryTypes = groqJs.typeEvaluate(ast, schema), typeName = `${queryName}Result`, type = typeGenerator.generateTypeNodeTypes(typeName, queryTypes), queryTypeStats = walkAndCountQueryTypeNodeStats(queryTypes);
-        fileQueryTypes.push({
-          queryName,
-          query,
-          typeName,
-          typeNode: queryTypes,
-          type: `${type.trim()}
-`,
-          unknownTypeNodesGenerated: queryTypeStats.unknownTypes,
-          typeNodesGenerated: queryTypeStats.allTypes,
-          emptyUnionTypeNodesGenerated: queryTypeStats.emptyUnions
-        });
-      } catch (err) {
-        node_worker_threads.parentPort?.postMessage({
-          type: "error",
-          error: new Error(
-            `Error generating types for query "${queryName}" in "${result.filename}": ${err.message}`,
-            { cause: err }
-          ),
-          fatal: !1,
-          query
-        });
-      }
-    fileQueryTypes.length > 0 && ($info(`Generated types for ${fileQueryTypes.length} queries in "${result.filename}"
-`), node_worker_threads.parentPort?.postMessage({
-      type: "types",
-      types: fileQueryTypes,
-      filename: result.filename
-    })), fileQueryTypes.length > 0 && allQueries.push(...fileQueryTypes);
-  }
-  if (opts.overloadClientMethods && allQueries.length > 0) {
-    const typeMap = `${typeGenerator.generateQueryMap(allQueries).trim()}
-`;
-    node_worker_threads.parentPort?.postMessage({
-      type: "typemap",
-      typeMap
+  const schemas = [];
+  for (const schemaConfig of opts.schemas) {
+    $info(`Reading schema from ${schemaConfig.schemaPath}...`);
+    const schema = await codegen.readSchema(schemaConfig.schemaPath);
+    schemas.push({
+      schema,
+      projectId: schemaConfig.projectId,
+      dataset: schemaConfig.dataset,
+      filename: schemaConfig.schemaPath
     });
   }
-  node_worker_threads.parentPort?.postMessage({
-    type: "complete"
+  $info(`Read ${schemas.length} schema definition${schemas.length === 1 ? "" : "s"} successfully.`);
+  const resolver = codegen.getResolver(), result = codegen.generateTypes({
+    schemas,
+    queriesByFile: codegen.findQueriesInPath({ path: opts.searchPath, resolver }),
+    augmentGroqModule: opts.augmentGroqModule,
+    overloadClientMethods: opts.overloadClientMethods
   });
+  report.event.schema(await result.generatedSchema());
+  for await (const { filename, results } of result.generatedQueries())
+    report.stream.queries.emit({ filename, results });
+  report.stream.queries.end(), report.event.typemap(await result.generatedTypemap());
 }
-function walkAndCountQueryTypeNodeStats(typeNode) {
-  switch (typeNode.type) {
-    case "unknown":
-      return { allTypes: 1, unknownTypes: 1, emptyUnions: 0 };
-    case "array": {
-      const acc = walkAndCountQueryTypeNodeStats(typeNode.of);
-      return acc.allTypes += 1, acc;
-    }
-    case "object": {
-      if (typeNode.rest && typeNode.rest.type === "unknown")
-        return { allTypes: 2, unknownTypes: 1, emptyUnions: 0 };
-      const restStats = typeNode.rest ? walkAndCountQueryTypeNodeStats(typeNode.rest) : { allTypes: 1, unknownTypes: 0, emptyUnions: 0 };
-      return Object.values(typeNode.attributes).reduce((acc, attribute) => {
-        const { allTypes, unknownTypes, emptyUnions } = walkAndCountQueryTypeNodeStats(
-          attribute.value
-        );
-        return {
-          allTypes: acc.allTypes + allTypes,
-          unknownTypes: acc.unknownTypes + unknownTypes,
-          emptyUnions: acc.emptyUnions + emptyUnions
-        };
-      }, restStats);
-    }
-    case "union":
-      return typeNode.of.length === 0 ? { allTypes: 1, unknownTypes: 0, emptyUnions: 1 } : typeNode.of.reduce(
-        (acc, type) => {
-          const { allTypes, unknownTypes, emptyUnions } = walkAndCountQueryTypeNodeStats(type);
-          return {
-            allTypes: acc.allTypes + allTypes,
-            unknownTypes: acc.unknownTypes + unknownTypes,
-            emptyUnions: acc.emptyUnions + emptyUnions
-          };
-        },
-        { allTypes: 1, unknownTypes: 0, emptyUnions: 0 }
-        // count the union type itself
-      );
-    default:
-      return { allTypes: 1, unknownTypes: 0, emptyUnions: 0 };
-  }
-}
+codegen.registerBabel();
 main();
 //# sourceMappingURL=typegenGenerate.js.map

package/lib/workers/typegenGenerate.js.map

@@ -1 +1 @@
-{"version":3,"file":"typegenGenerate.js","sources":["../../src/workers/typegenGenerate.ts"],"sourcesContent":["import {isMainThread, parentPort, workerData as _workerData} from 'node:worker_threads'\n\nimport {\n  findQueriesInPath,\n  getResolver,\n  readSchema,\n  registerBabel,\n  safeParseQuery,\n  TypeGenerator,\n} from '@sanity/codegen'\nimport createDebug from 'debug'\nimport {typeEvaluate, type TypeNode} from 'groq-js'\n\nconst $info = createDebug('sanity:codegen:generate:info')\nconst $warn = createDebug('sanity:codegen:generate:warn')\n\nexport interface TypegenGenerateTypesWorkerData {\n  workDir: string\n  workspaceName?: string\n  schemaPath: string\n  searchPath: string | string[]\n  overloadClientMethods?: boolean\n}\n\nexport type TypegenGenerateTypesWorkerMessage =\n  | {\n      type: 'error'\n      error: Error\n      fatal: boolean\n      query?: string\n      filename?: string\n    }\n  | {\n      type: 'types'\n      filename: string\n      types: {\n        queryName: string\n        query: string\n        type: string\n        unknownTypeNodesGenerated: number\n        typeNodesGenerated: number\n        emptyUnionTypeNodesGenerated: number\n      }[]\n    }\n  | {\n      type: 'schema'\n      filename: string\n      schema: string\n      length: number\n    }\n  | {\n      type: 'typemap'\n      typeMap: string\n    }\n  | {\n      type: 'complete'\n    }\n\nif (isMainThread || !parentPort) {\n  throw new Error('This module must be run as a worker thread')\n}\n\nconst opts = _workerData as TypegenGenerateTypesWorkerData\n\nregisterBabel()\n\nasync function main() {\n  const schema = await readSchema(opts.schemaPath)\n\n  const typeGenerator = new TypeGenerator(schema)\n  const schemaTypes = [typeGenerator.generateSchemaTypes(), TypeGenerator.generateKnownTypes()]\n    .join('\\n')\n    .trim()\n  const resolver = getResolver()\n\n  parentPort?.postMessage({\n    type: 'schema',\n    schema: `${schemaTypes.trim()}\\n`,\n    filename: 'schema.json',\n    length: schema.length,\n  } satisfies TypegenGenerateTypesWorkerMessage)\n\n  const queries = findQueriesInPath({\n    path: opts.searchPath,\n    resolver,\n  })\n\n  const allQueries = []\n\n  for await (const result of queries) {\n    if (result.type === 'error') {\n      parentPort?.postMessage({\n        type: 'error',\n        error: result.error,\n        fatal: false,\n        filename: result.filename,\n      } satisfies TypegenGenerateTypesWorkerMessage)\n      continue\n    }\n    $info(`Processing ${result.queries.length} queries in \"${result.filename}\"...`)\n\n    const fileQueryTypes: {\n      queryName: string\n      query: string\n      type: string\n      typeName: string\n      typeNode: TypeNode\n      unknownTypeNodesGenerated: number\n      typeNodesGenerated: number\n      emptyUnionTypeNodesGenerated: number\n    }[] = []\n    for (const {name: queryName, result: query} of result.queries) {\n      try {\n        const ast = safeParseQuery(query)\n        const queryTypes = typeEvaluate(ast, schema)\n\n        const typeName = `${queryName}Result`\n        const type = typeGenerator.generateTypeNodeTypes(typeName, queryTypes)\n\n        const queryTypeStats = walkAndCountQueryTypeNodeStats(queryTypes)\n        fileQueryTypes.push({\n          queryName,\n          query,\n          typeName,\n          typeNode: queryTypes,\n          type: `${type.trim()}\\n`,\n          unknownTypeNodesGenerated: queryTypeStats.unknownTypes,\n          typeNodesGenerated: queryTypeStats.allTypes,\n          emptyUnionTypeNodesGenerated: queryTypeStats.emptyUnions,\n        })\n      } catch (err) {\n        parentPort?.postMessage({\n          type: 'error',\n          error: new Error(\n            `Error generating types for query \"${queryName}\" in \"${result.filename}\": ${err.message}`,\n            {cause: err},\n          ),\n          fatal: false,\n          query,\n        } satisfies TypegenGenerateTypesWorkerMessage)\n      }\n    }\n\n    if (fileQueryTypes.length > 0) {\n      $info(`Generated types for ${fileQueryTypes.length} queries in \"${result.filename}\"\\n`)\n      parentPort?.postMessage({\n        type: 'types',\n        types: fileQueryTypes,\n        filename: result.filename,\n      } satisfies TypegenGenerateTypesWorkerMessage)\n    }\n\n    if (fileQueryTypes.length > 0) {\n      allQueries.push(...fileQueryTypes)\n    }\n  }\n\n  if (opts.overloadClientMethods && allQueries.length > 0) {\n    const typeMap = `${typeGenerator.generateQueryMap(allQueries).trim()}\\n`\n    parentPort?.postMessage({\n      type: 'typemap',\n      typeMap,\n    } satisfies TypegenGenerateTypesWorkerMessage)\n  }\n\n  parentPort?.postMessage({\n    type: 'complete',\n  } satisfies TypegenGenerateTypesWorkerMessage)\n}\n\nfunction walkAndCountQueryTypeNodeStats(typeNode: TypeNode): {\n  allTypes: number\n  unknownTypes: number\n  emptyUnions: number\n} {\n  switch (typeNode.type) {\n    case 'unknown': {\n      return {allTypes: 1, unknownTypes: 1, emptyUnions: 0}\n    }\n    case 'array': {\n      const acc = walkAndCountQueryTypeNodeStats(typeNode.of)\n      acc.allTypes += 1 // count the array type itself\n      return acc\n    }\n    case 'object': {\n      // if the rest is unknown, we count it as one unknown type\n      if (typeNode.rest && typeNode.rest.type === 'unknown') {\n        return {allTypes: 2, unknownTypes: 1, emptyUnions: 0} // count the object type itself as well\n      }\n\n      const restStats = typeNode.rest\n        ? walkAndCountQueryTypeNodeStats(typeNode.rest)\n        : {allTypes: 1, unknownTypes: 0, emptyUnions: 0} // count the object type itself\n\n      return Object.values(typeNode.attributes).reduce((acc, attribute) => {\n        const {allTypes, unknownTypes, emptyUnions} = walkAndCountQueryTypeNodeStats(\n          attribute.value,\n        )\n        return {\n          allTypes: acc.allTypes + allTypes,\n          unknownTypes: acc.unknownTypes + unknownTypes,\n          emptyUnions: acc.emptyUnions + emptyUnions,\n        }\n      }, restStats)\n    }\n    case 'union': {\n      if (typeNode.of.length === 0) {\n        return {allTypes: 1, unknownTypes: 0, emptyUnions: 1}\n      }\n\n      return typeNode.of.reduce(\n        (acc, type) => {\n          const {allTypes, unknownTypes, emptyUnions} = walkAndCountQueryTypeNodeStats(type)\n          return {\n            allTypes: acc.allTypes + allTypes,\n            unknownTypes: acc.unknownTypes + unknownTypes,\n            emptyUnions: acc.emptyUnions + emptyUnions,\n          }\n        },\n        {allTypes: 1, unknownTypes: 0, emptyUnions: 0}, // count the union type itself\n      )\n    }\n    default: {\n      return {allTypes: 1, unknownTypes: 0, emptyUnions: 0}\n    }\n  }\n}\n\nmain()\n"],"names":["createDebug","isMainThread","parentPort","_workerData","registerBabel","readSchema","TypeGenerator","getResolver","findQueriesInPath","safeParseQuery","typeEvaluate"],"mappings":";;;;;;AAaA,MAAM,QAAQA,qBAAAA,QAAY,8BAA8B;AAC1CA,6BAAY,8BAA8B;AA4CxD,IAAIC,oBAAAA,gBAAgB,CAACC,oBAAA;AACb,QAAA,IAAI,MAAM,4CAA4C;AAG9D,MAAM,OAAOC,oBAAA;AAEbC,QAAAA,cAAc;AAEd,eAAe,OAAO;AACd,QAAA,SAAS,MAAMC,mBAAW,KAAK,UAAU,GAEzC,gBAAgB,IAAIC,sBAAc,MAAM,GACxC,cAAc,CAAC,cAAc,oBAAoB,GAAGA,QAAAA,cAAc,mBAAmB,CAAC,EACzF,KAAK;AAAA,CAAI,EACT,KAAA,GACG,WAAWC,oBAAY;AAE7BL,sBAAAA,YAAY,YAAY;AAAA,IACtB,MAAM;AAAA,IACN,QAAQ,GAAG,YAAY,KAAM,CAAA;AAAA;AAAA,IAC7B,UAAU;AAAA,IACV,QAAQ,OAAO;AAAA,EAAA,CAC4B;AAE7C,QAAM,UAAUM,QAAAA,kBAAkB;AAAA,IAChC,MAAM,KAAK;AAAA,IACX;AAAA,EAAA,CACD,GAEK,aAAa,CAAC;AAEpB,mBAAiB,UAAU,SAAS;AAC9B,QAAA,OAAO,SAAS,SAAS;AAC3BN,0BAAAA,YAAY,YAAY;AAAA,QACtB,MAAM;AAAA,QACN,OAAO,OAAO;AAAA,QACd,OAAO;AAAA,QACP,UAAU,OAAO;AAAA,MAAA,CAC0B;AAC7C;AAAA,IAAA;AAEF,UAAM,cAAc,OAAO,QAAQ,MAAM,gBAAgB,OAAO,QAAQ,MAAM;AAE9E,UAAM,iBASA,CAAC;AACP,eAAW,EAAC,MAAM,WAAW,QAAQ,MAAA,KAAU,OAAO;AAChD,UAAA;AACI,cAAA,MAAMO,uBAAe,KAAK,GAC1B,aAAaC,OAAa,aAAA,KAAK,MAAM,GAErC,WAAW,GAAG,SAAS,UACvB,OAAO,cAAc,sBAAsB,UAAU,UAAU,GAE/D,iBAAiB,+BAA+B,UAAU;AAChE,uBAAe,KAAK;AAAA,UAClB;AAAA,UACA;AAAA,UACA;AAAA,UACA,UAAU;AAAA,UACV,MAAM,GAAG,KAAK,KAAM,CAAA;AAAA;AAAA,UACpB,2BAA2B,eAAe;AAAA,UAC1C,oBAAoB,eAAe;AAAA,UACnC,8BAA8B,eAAe;AAAA,QAAA,CAC9C;AAAA,eACM,KAAK;AACZR,4BAAAA,YAAY,YAAY;AAAA,UACtB,MAAM;AAAA,UACN,OAAO,IAAI;AAAA,YACT,qCAAqC,SAAS,SAAS,OAAO,QAAQ,MAAM,IAAI,OAAO;AAAA,YACvF,EAAC,OAAO,IAAG;AAAA,UACb;AAAA,UACA,OAAO;AAAA,UACP;AAAA,QAAA,CAC2C;AAAA,MAAA;AAI7C,mBAAe,SAAS,MAC1B,MAAM,uBAAuB,eAAe,MAAM,gBAAgB,OAAO,QAAQ;AAAA,CAAK,GACtFA,gCAAY,YAAY;AAAA,MACtB,MAAM;AAAA,MACN,OAAO;AAAA,MACP,UAAU,OAAO;AAAA,IAAA,CAC0B,IAG3C,eAAe,SAAS,KAC1B,WAAW,KAAK,GAAG,cAAc;AAAA,EAAA;AAIrC,MAAI,KAAK,yBAAyB,WAAW,SAAS,GAAG;AACvD,UAAM,UAAU,GAAG,cAAc,iBAAiB,UAAU,EAAE,KAAM,CAAA;AAAA;AACpEA,wBAAAA,YAAY,YAAY;AAAA,MACtB,MAAM;AAAA,MACN;AAAA,IAAA,CAC2C;AAAA,EAAA;AAG/CA,sBAAAA,YAAY,YAAY;AAAA,IACtB,MAAM;AAAA,EAAA,CACqC;AAC/C;AAEA,SAAS,+BAA+B,UAItC;AACA,UAAQ,SAAS,MAAM;AAAA,IACrB,KAAK;AACH,aAAO,EAAC,UAAU,GAAG,cAAc,GAAG,aAAa,EAAC;AAAA,IAEtD,KAAK,SAAS;AACN,YAAA,MAAM,+BAA+B,SAAS,EAAE;AACtD,aAAA,IAAI,YAAY,GACT;AAAA,IAAA;AAAA,IAET,KAAK,UAAU;AAEb,UAAI,SAAS,QAAQ,SAAS,KAAK,SAAS;AAC1C,eAAO,EAAC,UAAU,GAAG,cAAc,GAAG,aAAa,EAAC;AAGtD,YAAM,YAAY,SAAS,OACvB,+BAA+B,SAAS,IAAI,IAC5C,EAAC,UAAU,GAAG,cAAc,GAAG,aAAa,EAAC;AAE1C,aAAA,OAAO,OAAO,SAAS,UAAU,EAAE,OAAO,CAAC,KAAK,cAAc;AACnE,cAAM,EAAC,UAAU,cAAc,YAAe,IAAA;AAAA,UAC5C,UAAU;AAAA,QACZ;AACO,eAAA;AAAA,UACL,UAAU,IAAI,WAAW;AAAA,UACzB,cAAc,IAAI,eAAe;AAAA,UACjC,aAAa,IAAI,cAAc;AAAA,QACjC;AAAA,SACC,SAAS;AAAA,IAAA;AAAA,IAEd,KAAK;AACH,aAAI,SAAS,GAAG,WAAW,IAClB,EAAC,UAAU,GAAG,cAAc,GAAG,aAAa,EAAC,IAG/C,SAAS,GAAG;AAAA,QACjB,CAAC,KAAK,SAAS;AACb,gBAAM,EAAC,UAAU,cAAc,YAAW,IAAI,+BAA+B,IAAI;AAC1E,iBAAA;AAAA,YACL,UAAU,IAAI,WAAW;AAAA,YACzB,cAAc,IAAI,eAAe;AAAA,YACjC,aAAa,IAAI,cAAc;AAAA,UACjC;AAAA,QACF;AAAA,QACA,EAAC,UAAU,GAAG,cAAc,GAAG,aAAa,EAAC;AAAA;AAAA,MAC/C;AAAA,IAEF;AACE,aAAO,EAAC,UAAU,GAAG,cAAc,GAAG,aAAa,EAAC;AAAA,EAAA;AAG1D;AAEA,KAAK;"}
+{"version":3,"file":"typegenGenerate.js","sources":["../../src/workers/typegenGenerate.ts"],"sourcesContent":["import {isMainThread, parentPort, workerData as _workerData} from 'node:worker_threads'\n\nimport {\n  findQueriesInPath,\n  type GeneratedQueries,\n  type GeneratedSchema,\n  type GeneratedTypemap,\n  generateTypes,\n  getResolver,\n  readSchema,\n  registerBabel,\n} from '@sanity/codegen'\nimport createDebug from 'debug'\nimport {type SchemaType} from 'groq-js'\n\nimport {\n  createReporter,\n  type WorkerChannel,\n  type WorkerChannelEvent,\n  type WorkerChannelStream,\n} from '../util/workerChannel'\n\nconst $info = createDebug('sanity:codegen:generate:info')\n\nexport interface TypegenGenerateTypesWorkerData {\n  workDir: string\n  schemas: {\n    projectId: string | 'default'\n    dataset: string | 'default'\n    schemaPath: string\n  }[]\n  searchPath: string | string[]\n  overloadClientMethods: boolean\n  augmentGroqModule: boolean\n}\n\n/** @internal */\nexport type TypegenWorkerChannel = WorkerChannel<{\n  schema: WorkerChannelEvent<GeneratedSchema>\n  queries: WorkerChannelStream<GeneratedQueries>\n  typemap: WorkerChannelEvent<GeneratedTypemap>\n}>\n\nif (isMainThread || !parentPort) {\n  throw new Error('This module must be run as a worker thread')\n}\n\nconst report = createReporter<TypegenWorkerChannel>(parentPort)\nconst opts = _workerData as TypegenGenerateTypesWorkerData\n\nasync function main() {\n  const schemas: {\n    schema: SchemaType\n    projectId: string | 'default'\n    dataset: string | 'default'\n    filename: string\n  }[] = []\n\n  for (const schemaConfig of opts.schemas) {\n    $info(`Reading schema from ${schemaConfig.schemaPath}...`)\n    const schema = await readSchema(schemaConfig.schemaPath)\n    schemas.push({\n      schema,\n      projectId: schemaConfig.projectId,\n      dataset: schemaConfig.dataset,\n      filename: schemaConfig.schemaPath,\n    })\n  }\n  $info(`Read ${schemas.length} schema definition${schemas.length === 1 ? '' : 's'} successfully.`)\n\n  const resolver = getResolver()\n\n  const result = generateTypes({\n    schemas,\n    queriesByFile: findQueriesInPath({path: opts.searchPath, resolver}),\n    augmentGroqModule: opts.augmentGroqModule,\n    overloadClientMethods: opts.overloadClientMethods,\n  })\n\n  report.event.schema(await result.generatedSchema())\n\n  for await (const {filename, results} of result.generatedQueries()) {\n    report.stream.queries.emit({filename, results})\n  }\n  report.stream.queries.end()\n\n  report.event.typemap(await result.generatedTypemap())\n}\n\nregisterBabel()\nmain()\n"],"names":["createDebug","isMainThread","parentPort","createReporter","_workerData","readSchema","getResolver","generateTypes","findQueriesInPath","registerBabel"],"mappings":";;;;;;AAsBA,MAAM,QAAQA,yBAAY,8BAA8B;AAqBxD,IAAIC,oBAAAA,gBAAgB,CAACC,oBAAA;AACb,QAAA,IAAI,MAAM,4CAA4C;AAG9D,MAAM,SAASC,cAAA,eAAqCD,8BAAU,GACxD,OAAOE,oBAAA;AAEb,eAAe,OAAO;AACpB,QAAM,UAKA,CAAC;AAEI,aAAA,gBAAgB,KAAK,SAAS;AACjC,UAAA,uBAAuB,aAAa,UAAU,KAAK;AACzD,UAAM,SAAS,MAAMC,mBAAW,aAAa,UAAU;AACvD,YAAQ,KAAK;AAAA,MACX;AAAA,MACA,WAAW,aAAa;AAAA,MACxB,SAAS,aAAa;AAAA,MACtB,UAAU,aAAa;AAAA,IAAA,CACxB;AAAA,EAAA;AAEG,QAAA,QAAQ,QAAQ,MAAM,qBAAqB,QAAQ,WAAW,IAAI,KAAK,GAAG,gBAAgB;AAEhG,QAAM,WAAWC,QAAAA,eAEX,SAASC,QAAAA,cAAc;AAAA,IAC3B;AAAA,IACA,eAAeC,QAAkB,kBAAA,EAAC,MAAM,KAAK,YAAY,UAAS;AAAA,IAClE,mBAAmB,KAAK;AAAA,IACxB,uBAAuB,KAAK;AAAA,EAAA,CAC7B;AAED,SAAO,MAAM,OAAO,MAAM,OAAO,iBAAiB;AAElD,mBAAiB,EAAC,UAAU,QAAO,KAAK,OAAO,iBAAiB;AAC9D,WAAO,OAAO,QAAQ,KAAK,EAAC,UAAU,SAAQ;AAEzC,SAAA,OAAO,QAAQ,OAEtB,OAAO,MAAM,QAAQ,MAAM,OAAO,kBAAkB;AACtD;AAEAC,QAAAA,cAAc;AACd,KAAK;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanity/cli",
-  "version": "3.86.1",
+  "version": "3.86.2-experimental.0",
   "description": "Sanity CLI tool for managing Sanity installations, managing plugins, schemas and datasets",
   "keywords": [
     "sanity",
@@ -46,24 +46,13 @@
     "src",
     "templates"
   ],
-  "scripts": {
-    "build": "pkg-utils build --strict --check --clean",
-    "check:types": "tsc --project tsconfig.lib.json",
-    "clean": "rimraf lib",
-    "lint": "eslint --cache .",
-    "prepublishOnly": "turbo run build",
-    "test": "vitest",
-    "ts": "node -r esbuild-register",
-    "watch": "pkg-utils watch"
-  },
   "dependencies": {
     "@babel/traverse": "^7.23.5",
     "@sanity/client": "^6.29.0",
-    "@sanity/codegen": "3.86.1",
     "@sanity/runtime-cli": "^3.0.0",
     "@sanity/telemetry": "^0.8.0",
     "@sanity/template-validator": "^2.4.3",
-    "@sanity/util": "3.86.1",
+    "@sanity/util": "",
     "chalk": "^4.1.2",
     "debug": "^4.3.4",
     "decompress": "^4.2.0",
@@ -74,16 +63,14 @@
     "pkg-dir": "^5.0.0",
     "prettier": "^3.3.0",
     "semver": "^7.3.5",
-    "validate-npm-package-name": "^3.0.0"
+    "validate-npm-package-name": "^3.0.0",
+    "@sanity/codegen": "3.86.2-experimental.0"
   },
   "devDependencies": {
-    "@repo/package.config": "0.0.0",
-    "@repo/test-config": "0.0.0",
     "@rexxars/gitconfiglocal": "^3.0.1",
     "@rollup/plugin-node-resolve": "^15.2.3",
     "@sanity/eslint-config-studio": "^4.0.0",
     "@sanity/generate-help-url": "^3.0.0",
-    "@sanity/types": "3.86.1",
     "@types/babel__traverse": "^7.20.5",
     "@types/configstore": "^5.0.1",
     "@types/cpx": "^1.5.2",
@@ -130,10 +117,21 @@
     "vite": "^6.2.4",
     "vitest": "^3.1.1",
     "which": "^2.0.2",
-    "xdg-basedir": "^4.0.0"
+    "xdg-basedir": "^4.0.0",
+    "@repo/package.config": "0.0.0",
+    "@sanity/types": "3.86.1",
+    "@repo/test-config": "0.0.0"
   },
   "engines": {
     "node": ">=18"
   },
-  "gitHead": "9b19a1ca740b0a62231d80d6e9daaa8651478d39"
-}
+  "scripts": {
+    "build": "pkg-utils build --strict --check --clean",
+    "check:types": "tsc --project tsconfig.lib.json",
+    "clean": "rimraf lib",
+    "lint": "eslint --cache .",
+    "test": "vitest",
+    "ts": "node -r esbuild-register",
+    "watch": "pkg-utils watch"
+  }
+}

package/src/actions/typegen/generate.telemetry.ts

@@ -1,8 +1,9 @@
 import {defineTrace} from '@sanity/telemetry'
 
-interface TypesGeneratedTraceAttrubutes {
+interface TypesGeneratedTraceAttributes {
   outputSize: number
   queriesCount: number
+  projectionsCount: number
   schemaTypesCount: number
   queryFilesCount: number
   filesWithErrors: number
@@ -11,10 +12,11 @@ interface TypesGeneratedTraceAttrubutes {
   unknownTypeNodesRatio: number
   emptyUnionTypeNodesGenerated: number
   configOverloadClientMethods: boolean
+  configAugmentGroqModule: boolean
 }
 
-export const TypesGeneratedTrace = defineTrace<TypesGeneratedTraceAttrubutes>({
+export const TypesGeneratedTrace = defineTrace<TypesGeneratedTraceAttributes>({
   name: 'Types Generated',
-  version: 0,
+  version: 1,
   description: 'Trace emitted when generating TypeScript types for queries',
 })