@sanity/codegen 5.7.2 → 5.9.0-watch-mode.1

package/dist/_exports/index.js

@@ -1,7 +1,10 @@
+export { runTypegenGenerate } from '../actions/typegenGenerate.js';
+export { runTypegenWatcher } from '../actions/typegenWatch.js';
 export { TypegenGenerateCommand } from '../commands/typegen/generate.js';
 export { configDefinition, readConfig } from '../readConfig.js';
 export { readSchema } from '../readSchema.js';
 export { safeParseQuery } from '../safeParseQuery.js';
+export { TypegenWatchModeTrace, TypesGeneratedTrace } from '../typegen.telemetry.js';
 export { findQueriesInPath } from '../typescript/findQueriesInPath.js';
 export { findQueriesInSource } from '../typescript/findQueriesInSource.js';
 export { getResolver } from '../typescript/moduleResolver.js';

package/dist/_exports/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/_exports/index.ts"],"sourcesContent":["export {TypegenGenerateCommand} from '../commands/typegen/generate.js'\nexport {\n  type CodegenConfig,\n  configDefinition,\n  readConfig,\n  type TypeGenConfig,\n} from '../readConfig.js'\nexport {readSchema} from '../readSchema.js'\nexport {safeParseQuery} from '../safeParseQuery.js'\nexport {findQueriesInPath} from '../typescript/findQueriesInPath.js'\nexport {findQueriesInSource} from '../typescript/findQueriesInSource.js'\nexport {getResolver} from '../typescript/moduleResolver.js'\nexport {registerBabel} from '../typescript/registerBabel.js'\nexport {\n  type GenerateTypesOptions,\n  TypeGenerator,\n  type TypegenWorkerChannel,\n} from '../typescript/typeGenerator.js'\nexport {\n  type EvaluatedModule,\n  type EvaluatedQuery,\n  type ExtractedModule,\n  type ExtractedQuery,\n  QueryExtractionError,\n} from '../typescript/types.js'\nexport {type FilterByType, type Get} from '../typeUtils.js'\n"],"names":["TypegenGenerateCommand","configDefinition","readConfig","readSchema","safeParseQuery","findQueriesInPath","findQueriesInSource","getResolver","registerBabel","TypeGenerator","QueryExtractionError"],"mappings":"AAAA,SAAQA,sBAAsB,QAAO,kCAAiC;AACtE,SAEEC,gBAAgB,EAChBC,UAAU,QAEL,mBAAkB;AACzB,SAAQC,UAAU,QAAO,mBAAkB;AAC3C,SAAQC,cAAc,QAAO,uBAAsB;AACnD,SAAQC,iBAAiB,QAAO,qCAAoC;AACpE,SAAQC,mBAAmB,QAAO,uCAAsC;AACxE,SAAQC,WAAW,QAAO,kCAAiC;AAC3D,SAAQC,aAAa,QAAO,iCAAgC;AAC5D,SAEEC,aAAa,QAER,iCAAgC;AACvC,SAKEC,oBAAoB,QACf,yBAAwB"}
+{"version":3,"sources":["../../src/_exports/index.ts"],"sourcesContent":["export {runTypegenGenerate} from '../actions/typegenGenerate.js'\nexport {runTypegenWatcher} from '../actions/typegenWatch.js'\nexport {type GenerationResult, type RunTypegenOptions} from '../actions/types.js'\nexport {TypegenGenerateCommand} from '../commands/typegen/generate.js'\nexport {\n  type CodegenConfig,\n  configDefinition,\n  readConfig,\n  type TypeGenConfig,\n} from '../readConfig.js'\nexport {readSchema} from '../readSchema.js'\nexport {safeParseQuery} from '../safeParseQuery.js'\nexport {TypegenWatchModeTrace, TypesGeneratedTrace} from '../typegen.telemetry.js'\nexport {findQueriesInPath} from '../typescript/findQueriesInPath.js'\nexport {findQueriesInSource} from '../typescript/findQueriesInSource.js'\nexport {getResolver} from '../typescript/moduleResolver.js'\nexport {registerBabel} from '../typescript/registerBabel.js'\nexport {\n  type GenerateTypesOptions,\n  TypeGenerator,\n  type TypegenWorkerChannel,\n} from '../typescript/typeGenerator.js'\nexport {\n  type EvaluatedModule,\n  type EvaluatedQuery,\n  type ExtractedModule,\n  type ExtractedQuery,\n  QueryExtractionError,\n} from '../typescript/types.js'\nexport {type FilterByType, type Get} from '../typeUtils.js'\n"],"names":["runTypegenGenerate","runTypegenWatcher","TypegenGenerateCommand","configDefinition","readConfig","readSchema","safeParseQuery","TypegenWatchModeTrace","TypesGeneratedTrace","findQueriesInPath","findQueriesInSource","getResolver","registerBabel","TypeGenerator","QueryExtractionError"],"mappings":"AAAA,SAAQA,kBAAkB,QAAO,gCAA+B;AAChE,SAAQC,iBAAiB,QAAO,6BAA4B;AAE5D,SAAQC,sBAAsB,QAAO,kCAAiC;AACtE,SAEEC,gBAAgB,EAChBC,UAAU,QAEL,mBAAkB;AACzB,SAAQC,UAAU,QAAO,mBAAkB;AAC3C,SAAQC,cAAc,QAAO,uBAAsB;AACnD,SAAQC,qBAAqB,EAAEC,mBAAmB,QAAO,0BAAyB;AAClF,SAAQC,iBAAiB,QAAO,qCAAoC;AACpE,SAAQC,mBAAmB,QAAO,uCAAsC;AACxE,SAAQC,WAAW,QAAO,kCAAiC;AAC3D,SAAQC,aAAa,QAAO,iCAAgC;AAC5D,SAEEC,aAAa,QAER,iCAAgC;AACvC,SAKEC,oBAAoB,QACf,yBAAwB"}

package/dist/actions/streamProcessor.js

@@ -0,0 +1,108 @@
+import { writeFile } from 'node:fs/promises';
+import { spinner } from '@sanity/cli-core/ux';
+import { format, resolveConfig as resolvePrettierConfig } from 'prettier';
+import { count } from '../utils/count.js';
+import { debug } from '../utils/debug.js';
+import { formatPath } from '../utils/formatPath.js';
+import { getMessage } from '../utils/getMessage.js';
+import { percent } from '../utils/percent.js';
+import { generatedFileWarning } from './generatedFileWarning.js';
+/**
+ * Processes the event stream from a typegen worker thread.
+ *
+ * Listens to worker channel events, displays progress via CLI spinners,
+ * writes the generated types to disk, and optionally formats with prettier.
+ *
+ * @param receiver - Worker channel receiver for typegen events
+ * @param options - Typegen configuration options
+ * @returns Generation result containing the generated code and statistics
+ */ export async function processTypegenWorkerStream(receiver, options) {
+    const start = Date.now();
+    const { formatGeneratedCode, generates, schema } = options;
+    let code = '';
+    const spin = spinner().start(`Loading schema…`);
+    try {
+        await receiver.event.loadedSchema();
+        spin.succeed(`Schema loaded from ${formatPath(schema ?? '')}`);
+        spin.start('Generating schema types…');
+        const { expectedFileCount } = await receiver.event.typegenStarted();
+        const { schemaTypeDeclarations } = await receiver.event.generatedSchemaTypes();
+        const schemaTypesCount = schemaTypeDeclarations.length;
+        spin.text = 'Generating query types…';
+        let queriesCount = 0;
+        let evaluatedFiles = 0;
+        let filesWithErrors = 0;
+        let queryFilesCount = 0;
+        let typeNodesGenerated = 0;
+        let unknownTypeNodesGenerated = 0;
+        let emptyUnionTypeNodesGenerated = 0;
+        for await (const { errors, queries } of receiver.stream.evaluatedModules()){
+            evaluatedFiles++;
+            queriesCount += queries.length;
+            queryFilesCount += queries.length > 0 ? 1 : 0;
+            filesWithErrors += errors.length > 0 ? 1 : 0;
+            for (const { stats } of queries){
+                typeNodesGenerated += stats.allTypes;
+                unknownTypeNodesGenerated += stats.unknownTypes;
+                emptyUnionTypeNodesGenerated += stats.emptyUnions;
+            }
+            for (const error of errors){
+                spin.fail(getMessage(error));
+            }
+            if (!spin.isSpinning) {
+                spin.start();
+            }
+            spin.text = `Generating query types… (${percent(evaluatedFiles / expectedFileCount)})\n` + `  └─ Processed ${count(evaluatedFiles)} of ${count(expectedFileCount, 'files')}. ` + `Found ${count(queriesCount, 'queries', 'query')} from ${count(queryFilesCount, 'files')}.`;
+        }
+        const result = await receiver.event.typegenComplete();
+        code = `${generatedFileWarning}${result.code}`;
+        await writeFile(generates, code);
+        let formattingError = false;
+        if (formatGeneratedCode) {
+            spin.text = `Formatting generated types with prettier…`;
+            try {
+                const prettierConfig = await resolvePrettierConfig(generates);
+                const formattedCode = await format(code, {
+                    ...prettierConfig,
+                    parser: 'typescript'
+                });
+                await writeFile(generates, formattedCode);
+            } catch (err) {
+                formattingError = true;
+                spin.warn(`Failed to format generated types with prettier: ${getMessage(err)}`);
+            }
+        }
+        if (filesWithErrors > 0) {
+            spin.warn(`Encountered errors in ${count(filesWithErrors, 'files')} while generating types`);
+        }
+        const stats = {
+            duration: Date.now() - start,
+            emptyUnionTypeNodesGenerated,
+            filesWithErrors,
+            outputSize: Buffer.byteLength(code),
+            queriesCount,
+            queryFilesCount,
+            schemaTypesCount,
+            typeNodesGenerated,
+            unknownTypeNodesGenerated,
+            unknownTypeNodesRatio: typeNodesGenerated > 0 ? unknownTypeNodesGenerated / typeNodesGenerated : 0
+        };
+        let successText = `Successfully generated types to ${formatPath(generates)} in ${Number(stats.duration).toFixed(0)}ms` + `\n  └─ ${count(queriesCount, 'queries', 'query')} and ${count(schemaTypesCount, 'schema types', 'schema type')}` + `\n  └─ found queries in ${count(queryFilesCount, 'files', 'file')} after evaluating ${count(evaluatedFiles, 'files', 'file')}`;
+        if (formatGeneratedCode) {
+            successText += `\n  └─ ${formattingError ? 'an error occured during formatting' : 'formatted the generated code with prettier'}`;
+        }
+        spin.succeed(successText);
+        return {
+            ...stats,
+            code
+        };
+    } catch (err) {
+        spin.fail();
+        debug('error generating types', err);
+        throw err;
+    } finally{
+        receiver.unsubscribe();
+    }
+}
+
+//# sourceMappingURL=streamProcessor.js.map

package/dist/actions/streamProcessor.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/actions/streamProcessor.ts"],"sourcesContent":["import {writeFile} from 'node:fs/promises'\n\nimport {spinner} from '@sanity/cli-core/ux'\nimport {WorkerChannelReceiver} from '@sanity/worker-channels'\nimport {format, resolveConfig as resolvePrettierConfig} from 'prettier'\n\nimport {TypeGenConfig} from '../readConfig.js'\nimport {count} from '../utils/count.js'\nimport {debug} from '../utils/debug.js'\nimport {formatPath} from '../utils/formatPath.js'\nimport {getMessage} from '../utils/getMessage.js'\nimport {percent} from '../utils/percent.js'\nimport {generatedFileWarning} from './generatedFileWarning.js'\nimport {TypegenWorkerChannel} from './types.js'\n\n/**\n * Processes the event stream from a typegen worker thread.\n *\n * Listens to worker channel events, displays progress via CLI spinners,\n * writes the generated types to disk, and optionally formats with prettier.\n *\n * @param receiver - Worker channel receiver for typegen events\n * @param options - Typegen configuration options\n * @returns Generation result containing the generated code and statistics\n */\nexport async function processTypegenWorkerStream(\n  receiver: WorkerChannelReceiver<TypegenWorkerChannel>,\n  options: TypeGenConfig,\n) {\n  const start = Date.now()\n  const {formatGeneratedCode, generates, schema} = options\n  let code = ''\n\n  const spin = spinner().start(`Loading schema…`)\n\n  try {\n    await receiver.event.loadedSchema()\n    spin.succeed(`Schema loaded from ${formatPath(schema ?? '')}`)\n\n    spin.start('Generating schema types…')\n    const {expectedFileCount} = await receiver.event.typegenStarted()\n    const {schemaTypeDeclarations} = await receiver.event.generatedSchemaTypes()\n    const schemaTypesCount = schemaTypeDeclarations.length\n\n    spin.text = 'Generating query types…'\n\n    let queriesCount = 0\n    let evaluatedFiles = 0\n    let filesWithErrors = 0\n    let queryFilesCount = 0\n    let typeNodesGenerated = 0\n    let unknownTypeNodesGenerated = 0\n    let emptyUnionTypeNodesGenerated = 0\n\n    for await (const {errors, queries} of receiver.stream.evaluatedModules()) {\n      evaluatedFiles++\n      queriesCount += queries.length\n      queryFilesCount += queries.length > 0 ? 1 : 0\n      filesWithErrors += errors.length > 0 ? 1 : 0\n\n      for (const {stats} of queries) {\n        typeNodesGenerated += stats.allTypes\n        unknownTypeNodesGenerated += stats.unknownTypes\n        emptyUnionTypeNodesGenerated += stats.emptyUnions\n      }\n\n      for (const error of errors) {\n        spin.fail(getMessage(error))\n      }\n\n      if (!spin.isSpinning) {\n        spin.start()\n      }\n\n      spin.text =\n        `Generating query types… (${percent(evaluatedFiles / expectedFileCount)})\\n` +\n        `  └─ Processed ${count(evaluatedFiles)} of ${count(expectedFileCount, 'files')}. ` +\n        `Found ${count(queriesCount, 'queries', 'query')} from ${count(queryFilesCount, 'files')}.`\n    }\n\n    const result = await receiver.event.typegenComplete()\n    code = `${generatedFileWarning}${result.code}`\n    await writeFile(generates, code)\n\n    let formattingError = false\n    if (formatGeneratedCode) {\n      spin.text = `Formatting generated types with prettier…`\n\n      try {\n        const prettierConfig = await resolvePrettierConfig(generates)\n        const formattedCode = await format(code, {\n          ...prettierConfig,\n          parser: 'typescript' as const,\n        })\n        await writeFile(generates, formattedCode)\n      } catch (err) {\n        formattingError = true\n        spin.warn(`Failed to format generated types with prettier: ${getMessage(err)}`)\n      }\n    }\n\n    if (filesWithErrors > 0) {\n      spin.warn(`Encountered errors in ${count(filesWithErrors, 'files')} while generating types`)\n    }\n\n    const stats = {\n      duration: Date.now() - start,\n      emptyUnionTypeNodesGenerated,\n      filesWithErrors,\n      outputSize: Buffer.byteLength(code),\n      queriesCount,\n      queryFilesCount,\n      schemaTypesCount,\n      typeNodesGenerated,\n      unknownTypeNodesGenerated,\n      unknownTypeNodesRatio:\n        typeNodesGenerated > 0 ? unknownTypeNodesGenerated / typeNodesGenerated : 0,\n    }\n\n    let successText =\n      `Successfully generated types to ${formatPath(generates)} in ${Number(stats.duration).toFixed(0)}ms` +\n      `\\n  └─ ${count(queriesCount, 'queries', 'query')} and ${count(schemaTypesCount, 'schema types', 'schema type')}` +\n      `\\n  └─ found queries in ${count(queryFilesCount, 'files', 'file')} after evaluating ${count(evaluatedFiles, 'files', 'file')}`\n\n    if (formatGeneratedCode) {\n      successText += `\\n  └─ ${formattingError ? 'an error occured during formatting' : 'formatted the generated code with prettier'}`\n    }\n\n    spin.succeed(successText)\n\n    return {\n      ...stats,\n      code,\n    }\n  } catch (err) {\n    spin.fail()\n    debug('error generating types', err)\n    throw err\n  } finally {\n    receiver.unsubscribe()\n  }\n}\n"],"names":["writeFile","spinner","format","resolveConfig","resolvePrettierConfig","count","debug","formatPath","getMessage","percent","generatedFileWarning","processTypegenWorkerStream","receiver","options","start","Date","now","formatGeneratedCode","generates","schema","code","spin","event","loadedSchema","succeed","expectedFileCount","typegenStarted","schemaTypeDeclarations","generatedSchemaTypes","schemaTypesCount","length","text","queriesCount","evaluatedFiles","filesWithErrors","queryFilesCount","typeNodesGenerated","unknownTypeNodesGenerated","emptyUnionTypeNodesGenerated","errors","queries","stream","evaluatedModules","stats","allTypes","unknownTypes","emptyUnions","error","fail","isSpinning","result","typegenComplete","formattingError","prettierConfig","formattedCode","parser","err","warn","duration","outputSize","Buffer","byteLength","unknownTypeNodesRatio","successText","Number","toFixed","unsubscribe"],"mappings":"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"}

package/dist/actions/typegenGenerate.js

@@ -0,0 +1,55 @@
+import { mkdir } from 'node:fs/promises';
+import { dirname, isAbsolute, join } from 'node:path';
+import { env } from 'node:process';
+import { Worker } from 'node:worker_threads';
+import { WorkerChannelReceiver } from '@sanity/worker-channels';
+import { prepareConfig } from '../utils/config.js';
+import { debug } from '../utils/debug.js';
+import { processTypegenWorkerStream } from './streamProcessor.js';
+/**
+ * Runs a single typegen generation.
+ *
+ * This is the programmatic API for generating TypeScript types from GROQ queries.
+ * It spawns a worker thread to perform the generation and displays progress via CLI spinners.
+ *
+ * @param options - Configuration options including typegen config and working directory
+ * @returns Generation result containing the generated code and statistics
+ */ export async function runTypegenGenerate(options) {
+    const { config, workDir } = options;
+    const { formatGeneratedCode, generates, overloadClientMethods, path, schema } = prepareConfig(config);
+    const outputPath = isAbsolute(generates) ? generates : join(workDir, generates);
+    // create output dir if it isn't there
+    const outputDir = dirname(outputPath);
+    await mkdir(outputDir, {
+        recursive: true
+    });
+    // set up worker
+    const workerPath = new URL('../actions/typegenGenerate.worker.js', import.meta.url);
+    const workerData = {
+        overloadClientMethods,
+        schemaPath: schema,
+        searchPath: path,
+        workDir
+    };
+    const worker = new Worker(workerPath, {
+        env,
+        workerData
+    });
+    try {
+        const result = await processTypegenWorkerStream(WorkerChannelReceiver.from(worker), {
+            formatGeneratedCode,
+            generates: outputPath,
+            overloadClientMethods,
+            path,
+            schema
+        });
+        return result;
+    } catch (err) {
+        debug('error generating types', err);
+        throw err;
+    } finally{
+        worker.terminate();
+    }
+}
+
+//# sourceMappingURL=typegenGenerate.js.map

package/dist/actions/typegenGenerate.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/actions/typegenGenerate.ts"],"sourcesContent":["import {mkdir} from 'node:fs/promises'\nimport {dirname, isAbsolute, join} from 'node:path'\nimport {env} from 'node:process'\nimport {Worker} from 'node:worker_threads'\n\nimport {WorkerChannelReceiver} from '@sanity/worker-channels'\n\nimport {prepareConfig} from '../utils/config.js'\nimport {debug} from '../utils/debug.js'\nimport {processTypegenWorkerStream} from './streamProcessor.js'\nimport {\n  type GenerationResult,\n  type RunTypegenOptions,\n  TypegenGenerateTypesWorkerData,\n  TypegenWorkerChannel,\n} from './types.js'\n\n/**\n * Runs a single typegen generation.\n *\n * This is the programmatic API for generating TypeScript types from GROQ queries.\n * It spawns a worker thread to perform the generation and displays progress via CLI spinners.\n *\n * @param options - Configuration options including typegen config and working directory\n * @returns Generation result containing the generated code and statistics\n */\nexport async function runTypegenGenerate(options: RunTypegenOptions): Promise<GenerationResult> {\n  const {config, workDir} = options\n\n  const {formatGeneratedCode, generates, overloadClientMethods, path, schema} =\n    prepareConfig(config)\n\n  const outputPath = isAbsolute(generates) ? generates : join(workDir, generates)\n\n  // create output dir if it isn't there\n  const outputDir = dirname(outputPath)\n  await mkdir(outputDir, {recursive: true})\n\n  // set up worker\n  const workerPath = new URL('../actions/typegenGenerate.worker.js', import.meta.url)\n  const workerData: TypegenGenerateTypesWorkerData = {\n    overloadClientMethods,\n    schemaPath: schema,\n    searchPath: path,\n    workDir,\n  }\n  const worker = new Worker(workerPath, {env, workerData})\n\n  try {\n    const result = await processTypegenWorkerStream(\n      WorkerChannelReceiver.from<TypegenWorkerChannel>(worker),\n      {\n        formatGeneratedCode,\n        generates: outputPath,\n        overloadClientMethods,\n        path,\n        schema,\n      },\n    )\n\n    return result\n  } catch (err) {\n    debug('error generating types', err)\n    throw err\n  } finally {\n    worker.terminate()\n  }\n}\n"],"names":["mkdir","dirname","isAbsolute","join","env","Worker","WorkerChannelReceiver","prepareConfig","debug","processTypegenWorkerStream","runTypegenGenerate","options","config","workDir","formatGeneratedCode","generates","overloadClientMethods","path","schema","outputPath","outputDir","recursive","workerPath","URL","url","workerData","schemaPath","searchPath","worker","result","from","err","terminate"],"mappings":"AAAA,SAAQA,KAAK,QAAO,mBAAkB;AACtC,SAAQC,OAAO,EAAEC,UAAU,EAAEC,IAAI,QAAO,YAAW;AACnD,SAAQC,GAAG,QAAO,eAAc;AAChC,SAAQC,MAAM,QAAO,sBAAqB;AAE1C,SAAQC,qBAAqB,QAAO,0BAAyB;AAE7D,SAAQC,aAAa,QAAO,qBAAoB;AAChD,SAAQC,KAAK,QAAO,oBAAmB;AACvC,SAAQC,0BAA0B,QAAO,uBAAsB;AAQ/D;;;;;;;;CAQC,GACD,OAAO,eAAeC,mBAAmBC,OAA0B;IACjE,MAAM,EAACC,MAAM,EAAEC,OAAO,EAAC,GAAGF;IAE1B,MAAM,EAACG,mBAAmB,EAAEC,SAAS,EAAEC,qBAAqB,EAAEC,IAAI,EAAEC,MAAM,EAAC,GACzEX,cAAcK;IAEhB,MAAMO,aAAajB,WAAWa,aAAaA,YAAYZ,KAAKU,SAASE;IAErE,sCAAsC;IACtC,MAAMK,YAAYnB,QAAQkB;IAC1B,MAAMnB,MAAMoB,WAAW;QAACC,WAAW;IAAI;IAEvC,gBAAgB;IAChB,MAAMC,aAAa,IAAIC,IAAI,wCAAwC,YAAYC,GAAG;IAClF,MAAMC,aAA6C;QACjDT;QACAU,YAAYR;QACZS,YAAYV;QACZJ;IACF;IACA,MAAMe,SAAS,IAAIvB,OAAOiB,YAAY;QAAClB;QAAKqB;IAAU;IAEtD,IAAI;QACF,MAAMI,SAAS,MAAMpB,2BACnBH,sBAAsBwB,IAAI,CAAuBF,SACjD;YACEd;YACAC,WAAWI;YACXH;YACAC;YACAC;QACF;QAGF,OAAOW;IACT,EAAE,OAAOE,KAAK;QACZvB,MAAM,0BAA0BuB;QAChC,MAAMA;IACR,SAAU;QACRH,OAAOI,SAAS;IAClB;AACF"}

package/dist/actions/typegenWatch.js

@@ -0,0 +1,114 @@
+import { error, log } from 'node:console';
+import { isAbsolute, join, relative } from 'node:path';
+import { chalk } from '@sanity/cli-core/ux';
+import chokidar from 'chokidar';
+import { debounce, mean } from 'lodash-es';
+import { prepareConfig } from '../utils/config.js';
+import { runTypegenGenerate } from './typegenGenerate.js';
+const IGNORED_PATTERNS = [
+    '**/node_modules/**',
+    '**/.git/**',
+    '**/dist/**',
+    '**/lib/**',
+    '**/.sanity/**'
+];
+/**
+ * Creates a typegen runner with concurrency control.
+ * If generation is already running, queues one more generation to run after completion.
+ * Multiple queued requests are coalesced into a single pending generation.
+ */ export function createTypegenRunner(onGenerate) {
+    const state = {
+        isGenerating: false,
+        pendingGeneration: false
+    };
+    async function runGeneration() {
+        if (state.isGenerating) {
+            state.pendingGeneration = true;
+            return;
+        }
+        state.isGenerating = true;
+        state.pendingGeneration = false;
+        try {
+            await onGenerate();
+        } finally{
+            state.isGenerating = false;
+            // If a change came in during generation, run again
+            if (state.pendingGeneration) {
+                state.pendingGeneration = false;
+                await runGeneration();
+            }
+        }
+    }
+    return {
+        runGeneration,
+        state
+    };
+}
+/**
+ * Starts a file watcher that triggers typegen on changes.
+ * Watches both query files (via patterns) and the schema JSON file.
+ * Implements debouncing and concurrency control to prevent multiple generations.
+ */ export function runTypegenWatcher(options) {
+    const { config, workDir } = options;
+    const { path, schema } = prepareConfig(config);
+    const stats = {
+        failedCount: 0,
+        startTime: Date.now(),
+        successfulDurations: []
+    };
+    const { runGeneration } = createTypegenRunner(async ()=>{
+        try {
+            const { duration } = await runTypegenGenerate({
+                ...options
+            });
+            stats.successfulDurations.push(duration);
+        } catch (err) {
+            const errorMessage = err instanceof Error ? err.message : err;
+            error(` ${chalk.red('›')}   ${errorMessage}`);
+            stats.failedCount++;
+        }
+    });
+    // Debounced generation trigger
+    const debouncedGenerate = debounce(runGeneration, 1000);
+    // Build absolute patterns for query files and schema file
+    const paths = Array.isArray(path) ? path : [
+        path
+    ];
+    const absoluteQueryPatterns = paths.map((pattern)=>isAbsolute(pattern) ? pattern : join(workDir, pattern));
+    const absoluteSchemaPath = isAbsolute(schema) ? schema : join(workDir, schema);
+    const watchTargets = [
+        ...absoluteQueryPatterns,
+        absoluteSchemaPath
+    ];
+    // perform initial generation
+    debouncedGenerate();
+    // set up watcher
+    const watcher = chokidar.watch(watchTargets, {
+        cwd: workDir,
+        ignored: IGNORED_PATTERNS,
+        ignoreInitial: true
+    });
+    watcher.on('all', (event, filePath)=>{
+        const timestamp = new Date().toLocaleTimeString();
+        const relativePath = isAbsolute(filePath) ? relative(workDir, filePath) : filePath;
+        log(`[${timestamp}] ${event}: ${relativePath}`);
+        debouncedGenerate();
+    });
+    watcher.on('error', (err)=>{
+        error(`Watcher error: ${err.message}`);
+    });
+    return {
+        getStats: ()=>({
+                averageGenerationDuration: mean(stats.successfulDurations) || 0,
+                generationFailedCount: stats.failedCount,
+                generationSuccessfulCount: stats.successfulDurations.length,
+                watcherDuration: Date.now() - stats.startTime
+            }),
+        stop: async ()=>{
+            await watcher.close();
+        },
+        watcher
+    };
+}
+
+//# sourceMappingURL=typegenWatch.js.map

package/dist/actions/typegenWatch.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/actions/typegenWatch.ts"],"sourcesContent":["import {error, log} from 'node:console'\nimport {isAbsolute, join, relative} from 'node:path'\n\nimport {chalk} from '@sanity/cli-core/ux'\nimport chokidar, {FSWatcher} from 'chokidar'\nimport {debounce, mean} from 'lodash-es'\n\nimport {TypegenWatchModeTraceAttributes} from '../typegen.telemetry.js'\nimport {prepareConfig} from '../utils/config.js'\nimport {runTypegenGenerate} from './typegenGenerate.js'\nimport {type RunTypegenOptions} from './types.js'\n\nconst IGNORED_PATTERNS = [\n  '**/node_modules/**',\n  '**/.git/**',\n  '**/dist/**',\n  '**/lib/**',\n  '**/.sanity/**',\n]\n\n/** State for tracking generation status */\nexport interface WatchState {\n  isGenerating: boolean\n  pendingGeneration: boolean\n}\n\n/** Return type for createTypegenRunner */\ninterface TypegenRunner {\n  runGeneration: () => Promise<void>\n  state: WatchState\n}\n\ntype WatcherStats = Omit<Extract<TypegenWatchModeTraceAttributes, {step: 'stopped'}>, 'step'>\n\n/**\n * Creates a typegen runner with concurrency control.\n * If generation is already running, queues one more generation to run after completion.\n * Multiple queued requests are coalesced into a single pending generation.\n */\nexport function createTypegenRunner(onGenerate: () => Promise<unknown>): TypegenRunner {\n  const state: WatchState = {\n    isGenerating: false,\n    pendingGeneration: false,\n  }\n\n  async function runGeneration(): Promise<void> {\n    if (state.isGenerating) {\n      state.pendingGeneration = true\n      return\n    }\n\n    state.isGenerating = true\n    state.pendingGeneration = false\n\n    try {\n      await onGenerate()\n    } finally {\n      state.isGenerating = false\n\n      // If a change came in during generation, run again\n      if (state.pendingGeneration) {\n        state.pendingGeneration = false\n        await runGeneration()\n      }\n    }\n  }\n\n  return {runGeneration, state}\n}\n\n/**\n * Starts a file watcher that triggers typegen on changes.\n * Watches both query files (via patterns) and the schema JSON file.\n * Implements debouncing and concurrency control to prevent multiple generations.\n */\nexport function runTypegenWatcher(options: RunTypegenOptions): {\n  getStats: () => WatcherStats\n  stop: () => Promise<void>\n  watcher: FSWatcher\n} {\n  const {config, workDir} = options\n  const {path, schema} = prepareConfig(config)\n\n  const stats = {\n    failedCount: 0,\n    startTime: Date.now(),\n    successfulDurations: [] as number[],\n  }\n\n  const {runGeneration} = createTypegenRunner(async () => {\n    try {\n      const {duration} = await runTypegenGenerate({...options})\n      stats.successfulDurations.push(duration)\n    } catch (err) {\n      const errorMessage = err instanceof Error ? err.message : err\n      error(` ${chalk.red('›')}   ${errorMessage}`)\n      stats.failedCount++\n    }\n  })\n\n  // Debounced generation trigger\n  const debouncedGenerate = debounce(runGeneration, 1000)\n\n  // Build absolute patterns for query files and schema file\n  const paths = Array.isArray(path) ? path : [path]\n  const absoluteQueryPatterns = paths.map((pattern) =>\n    isAbsolute(pattern) ? pattern : join(workDir, pattern),\n  )\n  const absoluteSchemaPath = isAbsolute(schema) ? schema : join(workDir, schema)\n  const watchTargets = [...absoluteQueryPatterns, absoluteSchemaPath]\n\n  // perform initial generation\n  debouncedGenerate()\n\n  // set up watcher\n  const watcher = chokidar.watch(watchTargets, {\n    cwd: workDir,\n    ignored: IGNORED_PATTERNS,\n    ignoreInitial: true,\n  })\n\n  watcher.on('all', (event: string, filePath: string) => {\n    const timestamp = new Date().toLocaleTimeString()\n    const relativePath = isAbsolute(filePath) ? relative(workDir, filePath) : filePath\n    log(`[${timestamp}] ${event}: ${relativePath}`)\n    debouncedGenerate()\n  })\n\n  watcher.on('error', (err: Error) => {\n    error(`Watcher error: ${err.message}`)\n  })\n\n  return {\n    getStats: () => ({\n      averageGenerationDuration: mean(stats.successfulDurations) || 0,\n      generationFailedCount: stats.failedCount,\n      generationSuccessfulCount: stats.successfulDurations.length,\n      watcherDuration: Date.now() - stats.startTime,\n    }),\n    stop: async () => {\n      await watcher.close()\n    },\n    watcher,\n  }\n}\n"],"names":["error","log","isAbsolute","join","relative","chalk","chokidar","debounce","mean","prepareConfig","runTypegenGenerate","IGNORED_PATTERNS","createTypegenRunner","onGenerate","state","isGenerating","pendingGeneration","runGeneration","runTypegenWatcher","options","config","workDir","path","schema","stats","failedCount","startTime","Date","now","successfulDurations","duration","push","err","errorMessage","Error","message","red","debouncedGenerate","paths","Array","isArray","absoluteQueryPatterns","map","pattern","absoluteSchemaPath","watchTargets","watcher","watch","cwd","ignored","ignoreInitial","on","event","filePath","timestamp","toLocaleTimeString","relativePath","getStats","averageGenerationDuration","generationFailedCount","generationSuccessfulCount","length","watcherDuration","stop","close"],"mappings":"AAAA,SAAQA,KAAK,EAAEC,GAAG,QAAO,eAAc;AACvC,SAAQC,UAAU,EAAEC,IAAI,EAAEC,QAAQ,QAAO,YAAW;AAEpD,SAAQC,KAAK,QAAO,sBAAqB;AACzC,OAAOC,cAA2B,WAAU;AAC5C,SAAQC,QAAQ,EAAEC,IAAI,QAAO,YAAW;AAGxC,SAAQC,aAAa,QAAO,qBAAoB;AAChD,SAAQC,kBAAkB,QAAO,uBAAsB;AAGvD,MAAMC,mBAAmB;IACvB;IACA;IACA;IACA;IACA;CACD;AAgBD;;;;CAIC,GACD,OAAO,SAASC,oBAAoBC,UAAkC;IACpE,MAAMC,QAAoB;QACxBC,cAAc;QACdC,mBAAmB;IACrB;IAEA,eAAeC;QACb,IAAIH,MAAMC,YAAY,EAAE;YACtBD,MAAME,iBAAiB,GAAG;YAC1B;QACF;QAEAF,MAAMC,YAAY,GAAG;QACrBD,MAAME,iBAAiB,GAAG;QAE1B,IAAI;YACF,MAAMH;QACR,SAAU;YACRC,MAAMC,YAAY,GAAG;YAErB,mDAAmD;YACnD,IAAID,MAAME,iBAAiB,EAAE;gBAC3BF,MAAME,iBAAiB,GAAG;gBAC1B,MAAMC;YACR;QACF;IACF;IAEA,OAAO;QAACA;QAAeH;IAAK;AAC9B;AAEA;;;;CAIC,GACD,OAAO,SAASI,kBAAkBC,OAA0B;IAK1D,MAAM,EAACC,MAAM,EAAEC,OAAO,EAAC,GAAGF;IAC1B,MAAM,EAACG,IAAI,EAAEC,MAAM,EAAC,GAAGd,cAAcW;IAErC,MAAMI,QAAQ;QACZC,aAAa;QACbC,WAAWC,KAAKC,GAAG;QACnBC,qBAAqB,EAAE;IACzB;IAEA,MAAM,EAACZ,aAAa,EAAC,GAAGL,oBAAoB;QAC1C,IAAI;YACF,MAAM,EAACkB,QAAQ,EAAC,GAAG,MAAMpB,mBAAmB;gBAAC,GAAGS,OAAO;YAAA;YACvDK,MAAMK,mBAAmB,CAACE,IAAI,CAACD;QACjC,EAAE,OAAOE,KAAK;YACZ,MAAMC,eAAeD,eAAeE,QAAQF,IAAIG,OAAO,GAAGH;YAC1DhC,MAAM,CAAC,CAAC,EAAEK,MAAM+B,GAAG,CAAC,KAAK,GAAG,EAAEH,cAAc;YAC5CT,MAAMC,WAAW;QACnB;IACF;IAEA,+BAA+B;IAC/B,MAAMY,oBAAoB9B,SAASU,eAAe;IAElD,0DAA0D;IAC1D,MAAMqB,QAAQC,MAAMC,OAAO,CAAClB,QAAQA,OAAO;QAACA;KAAK;IACjD,MAAMmB,wBAAwBH,MAAMI,GAAG,CAAC,CAACC,UACvCzC,WAAWyC,WAAWA,UAAUxC,KAAKkB,SAASsB;IAEhD,MAAMC,qBAAqB1C,WAAWqB,UAAUA,SAASpB,KAAKkB,SAASE;IACvE,MAAMsB,eAAe;WAAIJ;QAAuBG;KAAmB;IAEnE,6BAA6B;IAC7BP;IAEA,iBAAiB;IACjB,MAAMS,UAAUxC,SAASyC,KAAK,CAACF,cAAc;QAC3CG,KAAK3B;QACL4B,SAAStC;QACTuC,eAAe;IACjB;IAEAJ,QAAQK,EAAE,CAAC,OAAO,CAACC,OAAeC;QAChC,MAAMC,YAAY,IAAI3B,OAAO4B,kBAAkB;QAC/C,MAAMC,eAAetD,WAAWmD,YAAYjD,SAASiB,SAASgC,YAAYA;QAC1EpD,IAAI,CAAC,CAAC,EAAEqD,UAAU,EAAE,EAAEF,MAAM,EAAE,EAAEI,cAAc;QAC9CnB;IACF;IAEAS,QAAQK,EAAE,CAAC,SAAS,CAACnB;QACnBhC,MAAM,CAAC,eAAe,EAAEgC,IAAIG,OAAO,EAAE;IACvC;IAEA,OAAO;QACLsB,UAAU,IAAO,CAAA;gBACfC,2BAA2BlD,KAAKgB,MAAMK,mBAAmB,KAAK;gBAC9D8B,uBAAuBnC,MAAMC,WAAW;gBACxCmC,2BAA2BpC,MAAMK,mBAAmB,CAACgC,MAAM;gBAC3DC,iBAAiBnC,KAAKC,GAAG,KAAKJ,MAAME,SAAS;YAC/C,CAAA;QACAqC,MAAM;YACJ,MAAMjB,QAAQkB,KAAK;QACrB;QACAlB;IACF;AACF"}

package/dist/actions/types.js

@@ -1,3 +1,6 @@
-export { };
+/**
+ * Result from a single generation run.
+ * @internal
+ */ export { };
 
 //# sourceMappingURL=types.js.map

package/dist/actions/types.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/actions/types.ts"],"sourcesContent":["import {WorkerChannel} from '@sanity/worker-channels'\n\nimport {type TypegenWorkerChannel as CodegenTypegenWorkerChannel} from '../typescript/typeGenerator.js'\n\nexport interface TypegenGenerateTypesWorkerData {\n  schemaPath: string\n  searchPath: string | string[]\n  workDir: string\n\n  overloadClientMethods?: boolean\n}\n\nexport type TypegenWorkerChannel = WorkerChannel.Definition<\n  CodegenTypegenWorkerChannel['__definition'] & {\n    loadedSchema: WorkerChannel.Event\n    typegenComplete: WorkerChannel.Event<{code: string}>\n    typegenStarted: WorkerChannel.Event<{expectedFileCount: number}>\n  }\n>\n"],"names":[],"mappings":"AAYA,WAMC"}
+{"version":3,"sources":["../../src/actions/types.ts"],"sourcesContent":["import {spinner} from '@sanity/cli-core/ux'\nimport {WorkerChannel} from '@sanity/worker-channels'\n\nimport {TypeGenConfig} from '../readConfig.js'\nimport {type TypegenWorkerChannel as CodegenTypegenWorkerChannel} from '../typescript/typeGenerator.js'\nimport {telemetry} from '../utils/telemetryLogger.js'\n\n/**\n * Data passed to the typegen worker thread.\n * @internal\n */\nexport interface TypegenGenerateTypesWorkerData {\n  /** Path to the schema JSON file */\n  schemaPath: string\n  /** Glob pattern(s) for finding query files */\n  searchPath: string | string[]\n  /** Working directory (project root) */\n  workDir: string\n\n  /** Whether to generate client method overloads */\n  overloadClientMethods?: boolean\n}\n\n/**\n * Worker channel definition for typegen worker communication.\n * Extends the base TypegenWorkerChannel with additional events for progress tracking.\n * @internal\n */\nexport type TypegenWorkerChannel = WorkerChannel.Definition<\n  CodegenTypegenWorkerChannel['__definition'] & {\n    loadedSchema: WorkerChannel.Event\n    typegenComplete: WorkerChannel.Event<{code: string}>\n    typegenStarted: WorkerChannel.Event<{expectedFileCount: number}>\n  }\n>\n\n/**\n * Options for running a single typegen generation.\n * This is the programmatic API for one-off generation without file watching.\n */\nexport interface RunTypegenOptions {\n  /** Working directory (usually project root) */\n  workDir: string\n\n  /** Typegen configuration */\n  config?: Partial<TypeGenConfig>\n\n  /** Optional spinner instance for progress display */\n  spin?: ReturnType<typeof spinner>\n\n  /** Optional telemetry instance for tracking usage */\n  telemetry?: typeof telemetry\n}\n\n/**\n * Result from a single generation run.\n * @internal\n */\nexport interface GenerationResult {\n  code: string\n  duration: number\n  emptyUnionTypeNodesGenerated: number\n  filesWithErrors: number\n  outputSize: number\n  queriesCount: number\n  queryFilesCount: number\n  schemaTypesCount: number\n  typeNodesGenerated: number\n  unknownTypeNodesGenerated: number\n  unknownTypeNodesRatio: number\n}\n"],"names":[],"mappings":"AAsDA;;;CAGC,GACD,WAYC"}

package/dist/commands/typegen/generate.js

@@ -1,17 +1,15 @@
-import { mkdir, stat, writeFile } from 'node:fs/promises';
-import { dirname, isAbsolute, join } from 'node:path';
-import { env } from 'node:process';
-import { Worker } from 'node:worker_threads';
+import { stat } from 'node:fs/promises';
 import { Flags } from '@oclif/core';
-import { SanityCommand, subdebug } from '@sanity/cli-core';
+import { SanityCommand } from '@sanity/cli-core';
 import { chalk, spinner } from '@sanity/cli-core/ux';
-import { WorkerChannelReceiver } from '@sanity/worker-channels';
-import { generatedFileWarning } from '../../actions/generatedFileWarning.js';
+import { omit, once } from 'lodash-es';
+import { runTypegenGenerate } from '../../actions/typegenGenerate.js';
+import { runTypegenWatcher } from '../../actions/typegenWatch.js';
 import { configDefinition, readConfig } from '../../readConfig.js';
-import { count } from '../../utils/count.js';
-import { formatPath } from '../../utils/formatPath.js';
-import { getMessage } from '../../utils/getMessage.js';
-import { percent } from '../../utils/percent.js';
+import { TypegenWatchModeTrace, TypesGeneratedTrace } from '../../typegen.telemetry.js';
+import { debug } from '../../utils/debug.js';
+import { promiseWithResolvers } from '../../utils/promiseWithResolvers.js';
+import { telemetry } from '../../utils/telemetryLogger.js';
 const description = `Sanity TypeGen (Beta)
 This command is currently in beta and may undergo significant changes. Feedback is welcome!
 
@@ -32,7 +30,6 @@ The default configuration values listed above are used if not overridden in your
 ${chalk.bold('Note:')}
 - The \`sanity schema extract\` command is a prerequisite for extracting your Sanity Studio schema into a \`schema.json\` file, which is then used by the \`sanity typegen generate\` command to generate type definitions.
 - While this tool is in beta, we encourage you to experiment with these configurations and provide feedback to help improve its functionality and usability.`.trim();
-const debug = subdebug('typegen:generate');
 /**
  * @internal
  */ export class TypegenGenerateCommand extends SanityCommand {
@@ -46,193 +43,143 @@ const debug = subdebug('typegen:generate');
     static flags = {
         'config-path': Flags.string({
             description: '[Default: sanity-typegen.json] Specifies the path to the typegen configuration file. This file should be a JSON file that contains settings for the type generation process.'
+        }),
+        watch: Flags.boolean({
+            default: false,
+            description: '[Default: false] Run the typegen in watch mode'
         })
     };
     async run() {
         const { flags } = await this.parse(TypegenGenerateCommand);
-        const workDir = (await this.getProjectRoot()).directory;
-        // TODO: Add telemetry
-        //   const trace = telemetry.trace(TypesGeneratedTrace)
-        // trace.start()
+        if (flags.watch) {
+            await this.runWatcher();
+            return;
+        }
+        await this.runSingle();
+    }
+    async getConfig() {
         const spin = spinner({}).start('Loading config…');
-        let typegenConfig;
-        let configPath;
-        let typegenConfigMethod;
         try {
-            const result = await this.getConfig(spin, flags['config-path']);
-            typegenConfig = result.config;
-            configPath = result.path;
-            typegenConfigMethod = result.type;
-            spin.succeed(`Config loaded from ${formatPath(configPath?.replace(workDir, '.') ?? '')}`);
-        } catch (error) {
-            debug('error loading config', error);
+            const { flags } = await this.parse(TypegenGenerateCommand);
+            const rootDir = await this.getProjectRoot();
+            const config = await this.getCliConfig();
+            const configPath = flags['config-path'];
+            const workDir = rootDir.directory;
+            // check if the legacy config exist
+            const legacyConfigPath = configPath || 'sanity-typegen.json';
+            let hasLegacyConfig = false;
+            try {
+                const file = await stat(legacyConfigPath);
+                hasLegacyConfig = file.isFile();
+            } catch (err) {
+                if (err instanceof Error && 'code' in err && err.code === 'ENOENT' && configPath) {
+                    spin.fail();
+                    this.error(`Typegen config file not found: ${configPath}`, {
+                        exit: 1
+                    });
+                }
+                if (err instanceof Error && 'code' in err && err.code !== 'ENOENT') {
+                    spin.fail();
+                    this.error(`Error when checking if typegen config file exists: ${legacyConfigPath}`, {
+                        exit: 1
+                    });
+                }
+            }
+            // we have both legacy and cli config with typegen
+            if (config?.typegen && hasLegacyConfig) {
+                spin.warn(chalk.yellow(`You've specified typegen in your Sanity CLI config, but also have a typegen config.
+
+    The config from the Sanity CLI config is used.
+    `));
+                return {
+                    config: configDefinition.parse(config.typegen || {}),
+                    path: rootDir.path,
+                    type: 'cli',
+                    workDir
+                };
+            }
+            // we only have legacy typegen config
+            if (hasLegacyConfig) {
+                spin.warn(chalk.yellow(`The separate typegen config has been deprecated. Use \`typegen\` in the sanity CLI config instead.
+
+    See: https://www.sanity.io/docs/help/configuring-typegen-in-sanity-cli-config`));
+                return {
+                    config: await readConfig(legacyConfigPath),
+                    path: legacyConfigPath,
+                    type: 'legacy',
+                    workDir
+                };
+            }
+            spin.succeed(`Config loaded from sanity.cli.ts`);
+            // we only have cli config
+            return {
+                config: configDefinition.parse(config.typegen || {}),
+                path: rootDir.path,
+                type: 'cli',
+                workDir
+            };
+        } catch (err) {
             spin.fail();
-            this.error(`${error instanceof Error ? error.message : 'Unknown error'}`, {
+            this.error(`An error occured during config loading ${err}`, {
                 exit: 1
             });
         }
-        const { formatGeneratedCode, generates, overloadClientMethods, path: searchPath, schema: schemaPath } = typegenConfig;
-        const outputPath = isAbsolute(typegenConfig.generates) ? typegenConfig.generates : join(workDir, typegenConfig.generates);
-        const outputDir = dirname(outputPath);
-        await mkdir(outputDir, {
-            recursive: true
-        });
-        const workerPath = new URL('../../actions/typegenGenerate.worker.js', import.meta.url);
-        const workerData = {
-            overloadClientMethods,
-            schemaPath,
-            searchPath,
-            workDir
-        };
-        const worker = new Worker(workerPath, {
-            env,
-            workerData
-        });
-        const receiver = WorkerChannelReceiver.from(worker);
+    }
+    async runSingle() {
+        const trace = telemetry.trace(TypesGeneratedTrace);
         try {
-            spin.start(`Loading schema…`);
-            await receiver.event.loadedSchema();
-            spin.succeed(`Schema loaded from ${formatPath(schemaPath ?? '')}`);
-            spin.start('Generating schema types…');
-            const { expectedFileCount } = await receiver.event.typegenStarted();
-            const { schemaTypeDeclarations } = await receiver.event.generatedSchemaTypes();
-            const schemaTypesCount = schemaTypeDeclarations.length;
-            spin.succeed(`Generated ${count(schemaTypesCount, 'schema types')}`);
-            spin.start('Generating query types…');
-            let queriesCount = 0;
-            let evaluatedFiles = 0;
-            let filesWithErrors = 0;
-            let queryFilesCount = 0;
-            let typeNodesGenerated = 0;
-            let unknownTypeNodesGenerated = 0;
-            let emptyUnionTypeNodesGenerated = 0;
-            for await (const { errors, queries } of receiver.stream.evaluatedModules()){
-                evaluatedFiles++;
-                queriesCount += queries.length;
-                queryFilesCount += queries.length > 0 ? 1 : 0;
-                filesWithErrors += errors.length > 0 ? 1 : 0;
-                for (const { stats } of queries){
-                    typeNodesGenerated += stats.allTypes;
-                    unknownTypeNodesGenerated += stats.unknownTypes;
-                    emptyUnionTypeNodesGenerated += stats.emptyUnions;
-                }
-                for (const error of errors){
-                    spin.fail(getMessage(error));
-                }
-                spin.text = `Generating query types… (${percent(evaluatedFiles / expectedFileCount)})\n` + `  └─ Processed ${count(evaluatedFiles)} of ${count(expectedFileCount, 'files')}. ` + `Found ${count(queriesCount, 'queries', 'query')} from ${count(queryFilesCount, 'files')}.`;
-            }
-            const result = await receiver.event.typegenComplete();
-            const code = `${generatedFileWarning}${result.code}`;
-            await writeFile(outputPath, code);
-            spin.succeed(`Generated ${count(queriesCount, 'query types')} from ${count(queryFilesCount, 'files')} out of ${count(evaluatedFiles, 'scanned files')}`);
-            if (formatGeneratedCode) {
-                spin.start(`Formatting generated types with prettier…`);
-                try {
-                    const prettier = await import('prettier');
-                    const prettierConfig = await prettier.resolveConfig(outputPath);
-                    const formattedCode = await prettier.format(code, {
-                        ...prettierConfig,
-                        parser: 'typescript'
-                    });
-                    await writeFile(outputPath, formattedCode);
-                    spin.succeed('Formatted generated types with prettier');
-                } catch (err) {
-                    spin.warn(`Failed to format generated types with prettier: ${getMessage(err)}`);
-                }
-            }
-            debug('trace', {
+            const { config: typegenConfig, type: typegenConfigMethod, workDir } = await this.getConfig();
+            trace.start();
+            const result = await runTypegenGenerate({
+                config: typegenConfig,
+                workDir
+            });
+            const traceStats = omit(result, 'code', 'duration');
+            trace.log({
                 configMethod: typegenConfigMethod,
-                configOverloadClientMethods: overloadClientMethods,
-                emptyUnionTypeNodesGenerated,
-                filesWithErrors,
-                outputSize: Buffer.byteLength(result.code),
-                queriesCount,
-                queryFilesCount,
-                schemaTypesCount,
-                typeNodesGenerated,
-                unknownTypeNodesGenerated,
-                unknownTypeNodesRatio: typeNodesGenerated > 0 ? unknownTypeNodesGenerated / typeNodesGenerated : 0
+                configOverloadClientMethods: typegenConfig.overloadClientMethods,
+                ...traceStats
             });
-            // trace.log({
-            //   configMethod: typegenConfigMethod,
-            //   configOverloadClientMethods: overloadClientMethods,
-            //   emptyUnionTypeNodesGenerated,
-            //   filesWithErrors,
-            //   outputSize: Buffer.byteLength(result.code),
-            //   queriesCount,
-            //   queryFilesCount,
-            //   schemaTypesCount,
-            //   typeNodesGenerated,
-            //   unknownTypeNodesGenerated,
-            //   unknownTypeNodesRatio:
-            //     typeNodesGenerated > 0 ? unknownTypeNodesGenerated / typeNodesGenerated : 0,
-            // })
-            if (filesWithErrors > 0) {
-                spin.warn(`Encountered errors in ${count(filesWithErrors, 'files')} while generating types`);
-            }
-            spin.succeed(`Successfully generated types to ${formatPath(generates)}`);
-        } catch (err) {
-            // trace.error(err)
-            debug('error generating types', err);
-            this.error(err instanceof Error ? err.message : 'Unknown error', {
+            trace.complete();
+        } catch (error) {
+            debug(error);
+            trace.error(error);
+            this.error(`${error instanceof Error ? error.message : 'Unknown error'}`, {
                 exit: 1
             });
-        } finally{
-            receiver.unsubscribe();
-            // trace.complete()
-            await worker.terminate();
         }
     }
-    async getConfig(spin, configPath) {
-        const rootDir = await this.getProjectRoot();
-        const config = await this.getCliConfig();
-        // check if the legacy config exist
-        const legacyConfigPath = configPath || 'sanity-typegen.json';
-        let hasLegacyConfig = false;
+    async runWatcher() {
+        const trace = telemetry.trace(TypegenWatchModeTrace);
         try {
-            const file = await stat(legacyConfigPath);
-            hasLegacyConfig = file.isFile();
-        } catch (err) {
-            if (err instanceof Error && 'code' in err && err.code === 'ENOENT' && configPath) {
-                throw new Error(`Typegen config file not found: ${configPath}`, {
-                    cause: err
-                });
-            }
-            if (err instanceof Error && 'code' in err && err.code !== 'ENOENT') {
-                throw new Error(`Error when checking if typegen config file exists: ${legacyConfigPath}`, {
-                    cause: err
+            const { config: typegenConfig, workDir } = await this.getConfig();
+            trace.start();
+            const { promise, resolve } = promiseWithResolvers();
+            const typegenWatcher = runTypegenWatcher({
+                config: typegenConfig,
+                workDir
+            });
+            const stop = once(async ()=>{
+                process.off('SIGINT', stop);
+                process.off('SIGTERM', stop);
+                trace.log({
+                    step: 'stopped',
+                    ...typegenWatcher.getStats()
                 });
-            }
-        }
-        // we have both legacy and cli config with typegen
-        if (config?.typegen && hasLegacyConfig) {
-            spin.warn(chalk.yellow(`You've specified typegen in your Sanity CLI config, but also have a typegen config.
-
-  The config from the Sanity CLI config is used.
-  `));
-            return {
-                config: configDefinition.parse(config.typegen || {}),
-                path: rootDir.path,
-                type: 'cli'
-            };
-        }
-        // we only have legacy typegen config
-        if (hasLegacyConfig) {
-            spin.warn(chalk.yellow(`The separate typegen config has been deprecated. Use \`typegen\` in the sanity CLI config instead.
-
-  See: https://www.sanity.io/docs/help/configuring-typegen-in-sanity-cli-config`));
-            return {
-                config: await readConfig(legacyConfigPath),
-                path: legacyConfigPath,
-                type: 'legacy'
-            };
+                trace.complete();
+                await typegenWatcher.stop();
+                resolve();
+            });
+            process.on('SIGINT', stop);
+            process.on('SIGTERM', stop);
+            await promise;
+        } catch (error) {
+            debug(error);
+            trace.error(error);
+            this.error(`${error instanceof Error ? error.message : 'Unknown error'}`, {
+                exit: 1
+            });
         }
-        // we only have cli config
-        return {
-            config: configDefinition.parse(config.typegen || {}),
-            path: rootDir.path,
-            type: 'cli'
-        };
     }
 }
 

package/dist/commands/typegen/generate.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/commands/typegen/generate.ts"],"sourcesContent":["import {mkdir, stat, writeFile} from 'node:fs/promises'\nimport {dirname, isAbsolute, join} from 'node:path'\nimport {env} from 'node:process'\nimport {Worker} from 'node:worker_threads'\n\nimport {Flags} from '@oclif/core'\nimport {SanityCommand, subdebug} from '@sanity/cli-core'\nimport {chalk, spinner} from '@sanity/cli-core/ux'\nimport {WorkerChannelReceiver} from '@sanity/worker-channels'\n\nimport {generatedFileWarning} from '../../actions/generatedFileWarning.js'\nimport {\n  type TypegenGenerateTypesWorkerData,\n  type TypegenWorkerChannel,\n} from '../../actions/types.js'\nimport {configDefinition, readConfig, type TypeGenConfig} from '../../readConfig.js'\nimport {count} from '../../utils/count.js'\nimport {formatPath} from '../../utils/formatPath.js'\nimport {getMessage} from '../../utils/getMessage.js'\nimport {percent} from '../../utils/percent.js'\n\nconst description = `Sanity TypeGen (Beta)\nThis command is currently in beta and may undergo significant changes. Feedback is welcome!\n\n${chalk.bold('Configuration:')}\nThis command can utilize configuration settings defined in a \\`sanity-typegen.json\\` file. These settings include:\n\n- \"path\": Specifies a glob pattern to locate your TypeScript or JavaScript files.\n  Default: \"./src/**/*.{ts,tsx,js,jsx}\"\n\n- \"schema\": Defines the path to your Sanity schema file. This file should be generated using the \\`sanity schema extract\\` command.\n  Default: \"schema.json\"\n\n- \"generates\": Indicates the path where the generated TypeScript type definitions will be saved.\n  Default: \"./sanity.types.ts\"\n\nThe default configuration values listed above are used if not overridden in your \\`sanity-typegen.json\\` configuration file. To customize the behavior of the type generation, adjust these properties in the configuration file according to your project's needs.\n\n${chalk.bold('Note:')}\n- The \\`sanity schema extract\\` command is a prerequisite for extracting your Sanity Studio schema into a \\`schema.json\\` file, which is then used by the \\`sanity typegen generate\\` command to generate type definitions.\n- While this tool is in beta, we encourage you to experiment with these configurations and provide feedback to help improve its functionality and usability.`.trim()\n\nconst debug = subdebug('typegen:generate')\n\n/**\n * @internal\n */\nexport class TypegenGenerateCommand extends SanityCommand<typeof TypegenGenerateCommand> {\n  static override description = description\n\n  static override examples = [\n    {\n      command: '<%= config.bin %> <%= command.id %>',\n      description: `Generate TypeScript type definitions from a Sanity Studio schema extracted using the \\`sanity schema extract\\` command.`,\n    },\n  ]\n\n  static override flags = {\n    'config-path': Flags.string({\n      description:\n        '[Default: sanity-typegen.json] Specifies the path to the typegen configuration file. This file should be a JSON file that contains settings for the type generation process.',\n    }),\n  }\n\n  public async run() {\n    const {flags} = await this.parse(TypegenGenerateCommand)\n    const workDir = (await this.getProjectRoot()).directory\n\n    // TODO: Add telemetry\n    //   const trace = telemetry.trace(TypesGeneratedTrace)\n    // trace.start()\n\n    const spin = spinner({}).start('Loading config…')\n\n    let typegenConfig: TypeGenConfig\n    let configPath: string | undefined\n    let typegenConfigMethod: 'cli' | 'legacy'\n\n    try {\n      const result = await this.getConfig(spin, flags['config-path'])\n      typegenConfig = result.config\n      configPath = result.path\n      typegenConfigMethod = result.type\n\n      spin.succeed(`Config loaded from ${formatPath(configPath?.replace(workDir, '.') ?? '')}`)\n    } catch (error) {\n      debug('error loading config', error)\n      spin.fail()\n      this.error(`${error instanceof Error ? error.message : 'Unknown error'}`, {\n        exit: 1,\n      })\n    }\n\n    const {\n      formatGeneratedCode,\n      generates,\n      overloadClientMethods,\n      path: searchPath,\n      schema: schemaPath,\n    } = typegenConfig\n\n    const outputPath = isAbsolute(typegenConfig.generates)\n      ? typegenConfig.generates\n      : join(workDir, typegenConfig.generates)\n\n    const outputDir = dirname(outputPath)\n    await mkdir(outputDir, {recursive: true})\n\n    const workerPath = new URL('../../actions/typegenGenerate.worker.js', import.meta.url)\n    const workerData: TypegenGenerateTypesWorkerData = {\n      overloadClientMethods,\n      schemaPath,\n      searchPath,\n      workDir,\n    }\n\n    const worker = new Worker(workerPath, {env, workerData})\n    const receiver = WorkerChannelReceiver.from<TypegenWorkerChannel>(worker)\n\n    try {\n      spin.start(`Loading schema…`)\n      await receiver.event.loadedSchema()\n      spin.succeed(`Schema loaded from ${formatPath(schemaPath ?? '')}`)\n\n      spin.start('Generating schema types…')\n      const {expectedFileCount} = await receiver.event.typegenStarted()\n      const {schemaTypeDeclarations} = await receiver.event.generatedSchemaTypes()\n      const schemaTypesCount = schemaTypeDeclarations.length\n      spin.succeed(`Generated ${count(schemaTypesCount, 'schema types')}`)\n\n      spin.start('Generating query types…')\n      let queriesCount = 0\n      let evaluatedFiles = 0\n      let filesWithErrors = 0\n      let queryFilesCount = 0\n      let typeNodesGenerated = 0\n      let unknownTypeNodesGenerated = 0\n      let emptyUnionTypeNodesGenerated = 0\n\n      for await (const {errors, queries} of receiver.stream.evaluatedModules()) {\n        evaluatedFiles++\n        queriesCount += queries.length\n        queryFilesCount += queries.length > 0 ? 1 : 0\n        filesWithErrors += errors.length > 0 ? 1 : 0\n\n        for (const {stats} of queries) {\n          typeNodesGenerated += stats.allTypes\n          unknownTypeNodesGenerated += stats.unknownTypes\n          emptyUnionTypeNodesGenerated += stats.emptyUnions\n        }\n\n        for (const error of errors) {\n          spin.fail(getMessage(error))\n        }\n\n        spin.text =\n          `Generating query types… (${percent(evaluatedFiles / expectedFileCount)})\\n` +\n          `  └─ Processed ${count(evaluatedFiles)} of ${count(expectedFileCount, 'files')}. ` +\n          `Found ${count(queriesCount, 'queries', 'query')} from ${count(queryFilesCount, 'files')}.`\n      }\n\n      const result = await receiver.event.typegenComplete()\n      const code = `${generatedFileWarning}${result.code}`\n      await writeFile(outputPath, code)\n\n      spin.succeed(\n        `Generated ${count(queriesCount, 'query types')} from ${count(queryFilesCount, 'files')} out of ${count(evaluatedFiles, 'scanned files')}`,\n      )\n\n      if (formatGeneratedCode) {\n        spin.start(`Formatting generated types with prettier…`)\n\n        try {\n          const prettier = await import('prettier')\n          const prettierConfig = await prettier.resolveConfig(outputPath)\n          const formattedCode = await prettier.format(code, {\n            ...prettierConfig,\n            parser: 'typescript' as const,\n          })\n          await writeFile(outputPath, formattedCode)\n\n          spin.succeed('Formatted generated types with prettier')\n        } catch (err) {\n          spin.warn(`Failed to format generated types with prettier: ${getMessage(err)}`)\n        }\n      }\n\n      debug('trace', {\n        configMethod: typegenConfigMethod,\n        configOverloadClientMethods: overloadClientMethods,\n        emptyUnionTypeNodesGenerated,\n        filesWithErrors,\n        outputSize: Buffer.byteLength(result.code),\n        queriesCount,\n        queryFilesCount,\n        schemaTypesCount,\n        typeNodesGenerated,\n        unknownTypeNodesGenerated,\n        unknownTypeNodesRatio:\n          typeNodesGenerated > 0 ? unknownTypeNodesGenerated / typeNodesGenerated : 0,\n      })\n      // trace.log({\n      //   configMethod: typegenConfigMethod,\n      //   configOverloadClientMethods: overloadClientMethods,\n      //   emptyUnionTypeNodesGenerated,\n      //   filesWithErrors,\n      //   outputSize: Buffer.byteLength(result.code),\n      //   queriesCount,\n      //   queryFilesCount,\n      //   schemaTypesCount,\n      //   typeNodesGenerated,\n      //   unknownTypeNodesGenerated,\n      //   unknownTypeNodesRatio:\n      //     typeNodesGenerated > 0 ? unknownTypeNodesGenerated / typeNodesGenerated : 0,\n      // })\n\n      if (filesWithErrors > 0) {\n        spin.warn(`Encountered errors in ${count(filesWithErrors, 'files')} while generating types`)\n      }\n\n      spin.succeed(`Successfully generated types to ${formatPath(generates)}`)\n    } catch (err) {\n      // trace.error(err)\n      debug('error generating types', err)\n      this.error(err instanceof Error ? err.message : 'Unknown error', {exit: 1})\n    } finally {\n      receiver.unsubscribe()\n      // trace.complete()\n      await worker.terminate()\n    }\n  }\n\n  private async getConfig(\n    spin: ReturnType<typeof spinner>,\n    configPath?: string,\n  ): Promise<{config: TypeGenConfig; path?: string; type: 'cli' | 'legacy'}> {\n    const rootDir = await this.getProjectRoot()\n    const config = await this.getCliConfig()\n\n    // check if the legacy config exist\n    const legacyConfigPath = configPath || 'sanity-typegen.json'\n    let hasLegacyConfig = false\n    try {\n      const file = await stat(legacyConfigPath)\n      hasLegacyConfig = file.isFile()\n    } catch (err) {\n      if (err instanceof Error && 'code' in err && err.code === 'ENOENT' && configPath) {\n        throw new Error(`Typegen config file not found: ${configPath}`, {cause: err})\n      }\n\n      if (err instanceof Error && 'code' in err && err.code !== 'ENOENT') {\n        throw new Error(`Error when checking if typegen config file exists: ${legacyConfigPath}`, {\n          cause: err,\n        })\n      }\n    }\n\n    // we have both legacy and cli config with typegen\n    if (config?.typegen && hasLegacyConfig) {\n      spin.warn(\n        chalk.yellow(\n          `You've specified typegen in your Sanity CLI config, but also have a typegen config.\n\n  The config from the Sanity CLI config is used.\n  `,\n        ),\n      )\n\n      return {\n        config: configDefinition.parse(config.typegen || {}),\n        path: rootDir.path,\n        type: 'cli',\n      }\n    }\n\n    // we only have legacy typegen config\n    if (hasLegacyConfig) {\n      spin.warn(\n        chalk.yellow(\n          `The separate typegen config has been deprecated. Use \\`typegen\\` in the sanity CLI config instead.\n\n  See: https://www.sanity.io/docs/help/configuring-typegen-in-sanity-cli-config`,\n        ),\n      )\n      return {\n        config: await readConfig(legacyConfigPath),\n        path: legacyConfigPath,\n        type: 'legacy',\n      }\n    }\n\n    // we only have cli config\n    return {\n      config: configDefinition.parse(config.typegen || {}),\n      path: rootDir.path,\n      type: 'cli',\n    }\n  }\n}\n"],"names":["mkdir","stat","writeFile","dirname","isAbsolute","join","env","Worker","Flags","SanityCommand","subdebug","chalk","spinner","WorkerChannelReceiver","generatedFileWarning","configDefinition","readConfig","count","formatPath","getMessage","percent","description","bold","trim","debug","TypegenGenerateCommand","examples","command","flags","string","run","parse","workDir","getProjectRoot","directory","spin","start","typegenConfig","configPath","typegenConfigMethod","result","getConfig","config","path","type","succeed","replace","error","fail","Error","message","exit","formatGeneratedCode","generates","overloadClientMethods","searchPath","schema","schemaPath","outputPath","outputDir","recursive","workerPath","URL","url","workerData","worker","receiver","from","event","loadedSchema","expectedFileCount","typegenStarted","schemaTypeDeclarations","generatedSchemaTypes","schemaTypesCount","length","queriesCount","evaluatedFiles","filesWithErrors","queryFilesCount","typeNodesGenerated","unknownTypeNodesGenerated","emptyUnionTypeNodesGenerated","errors","queries","stream","evaluatedModules","stats","allTypes","unknownTypes","emptyUnions","text","typegenComplete","code","prettier","prettierConfig","resolveConfig","formattedCode","format","parser","err","warn","configMethod","configOverloadClientMethods","outputSize","Buffer","byteLength","unknownTypeNodesRatio","unsubscribe","terminate","rootDir","getCliConfig","legacyConfigPath","hasLegacyConfig","file","isFile","cause","typegen","yellow"],"mappings":"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"}
+{"version":3,"sources":["../../../src/commands/typegen/generate.ts"],"sourcesContent":["import {stat} from 'node:fs/promises'\n\nimport {Flags} from '@oclif/core'\nimport {SanityCommand} from '@sanity/cli-core'\nimport {chalk, spinner} from '@sanity/cli-core/ux'\nimport {omit, once} from 'lodash-es'\n\nimport {runTypegenGenerate} from '../../actions/typegenGenerate.js'\nimport {runTypegenWatcher} from '../../actions/typegenWatch.js'\nimport {configDefinition, readConfig, type TypeGenConfig} from '../../readConfig.js'\nimport {TypegenWatchModeTrace, TypesGeneratedTrace} from '../../typegen.telemetry.js'\nimport {debug} from '../../utils/debug.js'\nimport {promiseWithResolvers} from '../../utils/promiseWithResolvers.js'\nimport {telemetry} from '../../utils/telemetryLogger.js'\n\nconst description = `Sanity TypeGen (Beta)\nThis command is currently in beta and may undergo significant changes. Feedback is welcome!\n\n${chalk.bold('Configuration:')}\nThis command can utilize configuration settings defined in a \\`sanity-typegen.json\\` file. These settings include:\n\n- \"path\": Specifies a glob pattern to locate your TypeScript or JavaScript files.\n  Default: \"./src/**/*.{ts,tsx,js,jsx}\"\n\n- \"schema\": Defines the path to your Sanity schema file. This file should be generated using the \\`sanity schema extract\\` command.\n  Default: \"schema.json\"\n\n- \"generates\": Indicates the path where the generated TypeScript type definitions will be saved.\n  Default: \"./sanity.types.ts\"\n\nThe default configuration values listed above are used if not overridden in your \\`sanity-typegen.json\\` configuration file. To customize the behavior of the type generation, adjust these properties in the configuration file according to your project's needs.\n\n${chalk.bold('Note:')}\n- The \\`sanity schema extract\\` command is a prerequisite for extracting your Sanity Studio schema into a \\`schema.json\\` file, which is then used by the \\`sanity typegen generate\\` command to generate type definitions.\n- While this tool is in beta, we encourage you to experiment with these configurations and provide feedback to help improve its functionality and usability.`.trim()\n\n/**\n * @internal\n */\nexport class TypegenGenerateCommand extends SanityCommand<typeof TypegenGenerateCommand> {\n  static override description = description\n\n  static override examples = [\n    {\n      command: '<%= config.bin %> <%= command.id %>',\n      description: `Generate TypeScript type definitions from a Sanity Studio schema extracted using the \\`sanity schema extract\\` command.`,\n    },\n  ]\n\n  static override flags = {\n    'config-path': Flags.string({\n      description:\n        '[Default: sanity-typegen.json] Specifies the path to the typegen configuration file. This file should be a JSON file that contains settings for the type generation process.',\n    }),\n    watch: Flags.boolean({\n      default: false,\n      description: '[Default: false] Run the typegen in watch mode',\n    }),\n  }\n\n  public async run() {\n    const {flags} = await this.parse(TypegenGenerateCommand)\n\n    if (flags.watch) {\n      await this.runWatcher()\n      return\n    }\n\n    await this.runSingle()\n  }\n\n  private async getConfig(): Promise<{\n    config: TypeGenConfig\n    path?: string\n    type: 'cli' | 'legacy'\n    workDir: string\n  }> {\n    const spin = spinner({}).start('Loading config…')\n\n    try {\n      const {flags} = await this.parse(TypegenGenerateCommand)\n      const rootDir = await this.getProjectRoot()\n      const config = await this.getCliConfig()\n\n      const configPath = flags['config-path']\n      const workDir = rootDir.directory\n\n      // check if the legacy config exist\n      const legacyConfigPath = configPath || 'sanity-typegen.json'\n      let hasLegacyConfig = false\n\n      try {\n        const file = await stat(legacyConfigPath)\n        hasLegacyConfig = file.isFile()\n      } catch (err) {\n        if (err instanceof Error && 'code' in err && err.code === 'ENOENT' && configPath) {\n          spin.fail()\n          this.error(`Typegen config file not found: ${configPath}`, {exit: 1})\n        }\n\n        if (err instanceof Error && 'code' in err && err.code !== 'ENOENT') {\n          spin.fail()\n          this.error(`Error when checking if typegen config file exists: ${legacyConfigPath}`, {\n            exit: 1,\n          })\n        }\n      }\n\n      // we have both legacy and cli config with typegen\n      if (config?.typegen && hasLegacyConfig) {\n        spin.warn(\n          chalk.yellow(\n            `You've specified typegen in your Sanity CLI config, but also have a typegen config.\n\n    The config from the Sanity CLI config is used.\n    `,\n          ),\n        )\n\n        return {\n          config: configDefinition.parse(config.typegen || {}),\n          path: rootDir.path,\n          type: 'cli',\n          workDir,\n        }\n      }\n\n      // we only have legacy typegen config\n      if (hasLegacyConfig) {\n        spin.warn(\n          chalk.yellow(\n            `The separate typegen config has been deprecated. Use \\`typegen\\` in the sanity CLI config instead.\n\n    See: https://www.sanity.io/docs/help/configuring-typegen-in-sanity-cli-config`,\n          ),\n        )\n        return {\n          config: await readConfig(legacyConfigPath),\n          path: legacyConfigPath,\n          type: 'legacy',\n          workDir,\n        }\n      }\n\n      spin.succeed(`Config loaded from sanity.cli.ts`)\n\n      // we only have cli config\n      return {\n        config: configDefinition.parse(config.typegen || {}),\n        path: rootDir.path,\n        type: 'cli',\n        workDir,\n      }\n    } catch (err) {\n      spin.fail()\n      this.error(`An error occured during config loading ${err}`, {exit: 1})\n    }\n  }\n\n  private async runSingle() {\n    const trace = telemetry.trace(TypesGeneratedTrace)\n\n    try {\n      const {config: typegenConfig, type: typegenConfigMethod, workDir} = await this.getConfig()\n      trace.start()\n\n      const result = await runTypegenGenerate({\n        config: typegenConfig,\n        workDir,\n      })\n\n      const traceStats = omit(result, 'code', 'duration')\n\n      trace.log({\n        configMethod: typegenConfigMethod,\n        configOverloadClientMethods: typegenConfig.overloadClientMethods,\n        ...traceStats,\n      })\n      trace.complete()\n    } catch (error) {\n      debug(error)\n      trace.error(error as Error)\n      this.error(`${error instanceof Error ? error.message : 'Unknown error'}`, {\n        exit: 1,\n      })\n    }\n  }\n\n  private async runWatcher() {\n    const trace = telemetry.trace(TypegenWatchModeTrace)\n\n    try {\n      const {config: typegenConfig, workDir} = await this.getConfig()\n      trace.start()\n\n      const {promise, resolve} = promiseWithResolvers()\n\n      const typegenWatcher = runTypegenWatcher({\n        config: typegenConfig,\n        workDir,\n      })\n\n      const stop = once(async () => {\n        process.off('SIGINT', stop)\n        process.off('SIGTERM', stop)\n\n        trace.log({\n          step: 'stopped',\n          ...typegenWatcher.getStats(),\n        })\n        trace.complete()\n\n        await typegenWatcher.stop()\n        resolve()\n      })\n\n      process.on('SIGINT', stop)\n      process.on('SIGTERM', stop)\n\n      await promise\n    } catch (error) {\n      debug(error)\n      trace.error(error as Error)\n      this.error(`${error instanceof Error ? error.message : 'Unknown error'}`, {\n        exit: 1,\n      })\n    }\n  }\n}\n"],"names":["stat","Flags","SanityCommand","chalk","spinner","omit","once","runTypegenGenerate","runTypegenWatcher","configDefinition","readConfig","TypegenWatchModeTrace","TypesGeneratedTrace","debug","promiseWithResolvers","telemetry","description","bold","trim","TypegenGenerateCommand","examples","command","flags","string","watch","boolean","default","run","parse","runWatcher","runSingle","getConfig","spin","start","rootDir","getProjectRoot","config","getCliConfig","configPath","workDir","directory","legacyConfigPath","hasLegacyConfig","file","isFile","err","Error","code","fail","error","exit","typegen","warn","yellow","path","type","succeed","trace","typegenConfig","typegenConfigMethod","result","traceStats","log","configMethod","configOverloadClientMethods","overloadClientMethods","complete","message","promise","resolve","typegenWatcher","stop","process","off","step","getStats","on"],"mappings":"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"}

package/dist/index.d.ts

@@ -1,9 +1,14 @@
+import { BooleanFlag } from '@oclif/core/interfaces';
 import { CustomOptions } from '@oclif/core/interfaces';
+import { DefinedTelemetryTrace } from '@sanity/telemetry';
 import { ExprNode } from 'groq-js';
+import { FSWatcher } from 'chokidar';
 import { OptionFlag } from '@oclif/core/interfaces';
 import { SanityCommand } from '@sanity/cli-core';
 import { SchemaType } from 'groq-js';
+import { spinner } from '@sanity/cli-core/ux';
 import * as t from '@babel/types';
+import { TelemetryLogger } from '@sanity/telemetry';
 import { TransformOptions } from '@babel/core';
 import { WorkerChannel } from '@sanity/worker-channels';
 import { WorkerChannelReporter } from '@sanity/worker-channels';
@@ -149,6 +154,24 @@ export declare interface GenerateTypesOptions {
     schemaPath?: string;
 }
 
+/**
+ * Result from a single generation run.
+ * @internal
+ */
+export declare interface GenerationResult {
+    code: string;
+    duration: number;
+    emptyUnionTypeNodesGenerated: number;
+    filesWithErrors: number;
+    outputSize: number;
+    queriesCount: number;
+    queryFilesCount: number;
+    schemaTypesCount: number;
+    typeNodesGenerated: number;
+    unknownTypeNodesGenerated: number;
+    unknownTypeNodesRatio: number;
+}
+
 /**
  * Get a deeply nested property type from a complex type structure. Safely navigates
  * through nullable types (`T | null | undefined`) at each level, preserving the
@@ -378,6 +401,43 @@ export declare function readSchema(path: string): Promise<SchemaType>;
  */
 export declare function registerBabel(babelOptions?: TransformOptions): void;
 
+/**
+ * Runs a single typegen generation.
+ *
+ * This is the programmatic API for generating TypeScript types from GROQ queries.
+ * It spawns a worker thread to perform the generation and displays progress via CLI spinners.
+ *
+ * @param options - Configuration options including typegen config and working directory
+ * @returns Generation result containing the generated code and statistics
+ */
+export declare function runTypegenGenerate(options: RunTypegenOptions): Promise<GenerationResult>;
+
+/**
+ * Options for running a single typegen generation.
+ * This is the programmatic API for one-off generation without file watching.
+ */
+export declare interface RunTypegenOptions {
+    /** Working directory (usually project root) */
+    workDir: string;
+    /** Typegen configuration */
+    config?: Partial<TypeGenConfig>;
+    /** Optional spinner instance for progress display */
+    spin?: ReturnType<typeof spinner>;
+    /** Optional telemetry instance for tracking usage */
+    telemetry?: typeof telemetry;
+}
+
+/**
+ * Starts a file watcher that triggers typegen on changes.
+ * Watches both query files (via patterns) and the schema JSON file.
+ * Implements debouncing and concurrency control to prevent multiple generations.
+ */
+export declare function runTypegenWatcher(options: RunTypegenOptions): {
+    getStats: () => WatcherStats;
+    stop: () => Promise<void>;
+    watcher: FSWatcher;
+};
+
 /**
  * safeParseQuery parses a GROQ query string, but first attempts to extract any parameters used in slices. This method is _only_
  * intended for use in type generation where we don't actually execute the parsed AST on a dataset, and should not be used elsewhere.
@@ -388,6 +448,13 @@ export declare function safeParseQuery(query: string): ExprNode;
 /** Builds a tuple from elements, stopping at the first `never`. */
 declare type TakeUntilNever<T extends unknown[]> = T extends [infer H, ...infer Rest] ? [H] extends [never] ? [] : [H, ...TakeUntilNever<Rest>] : [];
 
+/**
+ * TODO: Remove once we have a proper telemetry logger through the `@sanity/cli-core`
+ *
+ * This logger does nothing, except provide the interface to interact with
+ */
+declare const telemetry: TelemetryLogger<unknown>;
+
 /**
  * Statistics from the query type evaluation process.
  * @public
@@ -429,11 +496,30 @@ export declare class TypegenGenerateCommand extends SanityCommand<typeof Typegen
     }[];
     static flags: {
         'config-path': OptionFlag<string | undefined, CustomOptions>;
+        watch: BooleanFlag<boolean>;
     };
     run(): Promise<void>;
     private getConfig;
+    private runSingle;
+    private runWatcher;
 }
 
+export declare const TypegenWatchModeTrace: DefinedTelemetryTrace<TypegenWatchModeTraceAttributes, void>;
+
+/**
+ * Attributes for typegen watch mode trace - tracks the start and stop of watch mode
+ * sessions with statistics about generation runs.
+ */
+declare type TypegenWatchModeTraceAttributes = {
+    averageGenerationDuration: number;
+    generationFailedCount: number;
+    generationSuccessfulCount: number;
+    step: 'stopped';
+    watcherDuration: number;
+} | {
+    step: 'started';
+};
+
 export declare type TypegenWorkerChannel = WorkerChannel.Definition<{
     evaluatedModules: WorkerChannel.Stream<EvaluatedModule>;
     generatedQueryTypes: WorkerChannel.Event<{
@@ -463,4 +549,24 @@ export declare type TypegenWorkerChannel = WorkerChannel.Definition<{
     }>;
 }>;
 
+export declare const TypesGeneratedTrace: DefinedTelemetryTrace<TypesGeneratedTraceAttributes, void>;
+
+declare interface TypesGeneratedTraceAttributes {
+    configMethod: 'cli' | 'legacy';
+    configOverloadClientMethods: boolean;
+    emptyUnionTypeNodesGenerated: number;
+    filesWithErrors: number;
+    outputSize: number;
+    queriesCount: number;
+    queryFilesCount: number;
+    schemaTypesCount: number;
+    typeNodesGenerated: number;
+    unknownTypeNodesGenerated: number;
+    unknownTypeNodesRatio: number;
+}
+
+declare type WatcherStats = Omit<Extract<TypegenWatchModeTraceAttributes, {
+    step: 'stopped';
+}>, 'step'>;
+
 export { }

package/dist/typegen.telemetry.js

@@ -0,0 +1,13 @@
+import { defineTrace } from '@sanity/telemetry';
+export const TypesGeneratedTrace = defineTrace({
+    description: 'Trace emitted when generating TypeScript types for queries',
+    name: 'Types Generated',
+    version: 0
+});
+export const TypegenWatchModeTrace = defineTrace({
+    description: 'Trace emitted when typegen watch mode is run',
+    name: 'Typegen Watch Mode Started',
+    version: 0
+});
+
+//# sourceMappingURL=typegen.telemetry.js.map

package/dist/typegen.telemetry.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/typegen.telemetry.ts"],"sourcesContent":["import {defineTrace} from '@sanity/telemetry'\n\ninterface TypesGeneratedTraceAttributes {\n  configMethod: 'cli' | 'legacy'\n  configOverloadClientMethods: boolean\n  emptyUnionTypeNodesGenerated: number\n  filesWithErrors: number\n  outputSize: number\n  queriesCount: number\n  queryFilesCount: number\n  schemaTypesCount: number\n  typeNodesGenerated: number\n  unknownTypeNodesGenerated: number\n  unknownTypeNodesRatio: number\n}\n\nexport const TypesGeneratedTrace = defineTrace<TypesGeneratedTraceAttributes>({\n  description: 'Trace emitted when generating TypeScript types for queries',\n  name: 'Types Generated',\n  version: 0,\n})\n\n/**\n * Attributes for typegen watch mode trace - tracks the start and stop of watch mode\n * sessions with statistics about generation runs.\n */\nexport type TypegenWatchModeTraceAttributes =\n  | {\n      averageGenerationDuration: number\n      generationFailedCount: number\n      generationSuccessfulCount: number\n      step: 'stopped'\n      watcherDuration: number\n    }\n  | {\n      step: 'started'\n    }\n\nexport const TypegenWatchModeTrace = defineTrace<TypegenWatchModeTraceAttributes>({\n  description: 'Trace emitted when typegen watch mode is run',\n  name: 'Typegen Watch Mode Started',\n  version: 0,\n})\n"],"names":["defineTrace","TypesGeneratedTrace","description","name","version","TypegenWatchModeTrace"],"mappings":"AAAA,SAAQA,WAAW,QAAO,oBAAmB;AAgB7C,OAAO,MAAMC,sBAAsBD,YAA2C;IAC5EE,aAAa;IACbC,MAAM;IACNC,SAAS;AACX,GAAE;AAkBF,OAAO,MAAMC,wBAAwBL,YAA6C;IAChFE,aAAa;IACbC,MAAM;IACNC,SAAS;AACX,GAAE"}

package/dist/utils/config.js

@@ -0,0 +1,11 @@
+export function prepareConfig(config) {
+    return {
+        formatGeneratedCode: config?.formatGeneratedCode ?? false,
+        generates: config?.generates ?? 'sanity.types.ts',
+        overloadClientMethods: config?.overloadClientMethods ?? false,
+        path: config?.path ?? './src/**/*.{ts,tsx,js,jsx}',
+        schema: config?.schema ?? 'schema.json'
+    };
+}
+
+//# sourceMappingURL=config.js.map

package/dist/utils/config.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/config.ts"],"sourcesContent":["import {TypeGenConfig} from '../readConfig.js'\n\nexport function prepareConfig(config?: Partial<TypeGenConfig>): TypeGenConfig {\n  return {\n    formatGeneratedCode: config?.formatGeneratedCode ?? false,\n    generates: config?.generates ?? 'sanity.types.ts',\n    overloadClientMethods: config?.overloadClientMethods ?? false,\n    path: config?.path ?? './src/**/*.{ts,tsx,js,jsx}',\n    schema: config?.schema ?? 'schema.json',\n  }\n}\n"],"names":["prepareConfig","config","formatGeneratedCode","generates","overloadClientMethods","path","schema"],"mappings":"AAEA,OAAO,SAASA,cAAcC,MAA+B;IAC3D,OAAO;QACLC,qBAAqBD,QAAQC,uBAAuB;QACpDC,WAAWF,QAAQE,aAAa;QAChCC,uBAAuBH,QAAQG,yBAAyB;QACxDC,MAAMJ,QAAQI,QAAQ;QACtBC,QAAQL,QAAQK,UAAU;IAC5B;AACF"}

package/dist/utils/debug.js

@@ -0,0 +1,4 @@
+import { subdebug } from '@sanity/cli-core';
+export const debug = subdebug('typegen:generate');
+
+//# sourceMappingURL=debug.js.map

package/dist/utils/debug.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/debug.ts"],"sourcesContent":["import {subdebug} from '@sanity/cli-core'\n\nexport const debug = subdebug('typegen:generate')\n"],"names":["subdebug","debug"],"mappings":"AAAA,SAAQA,QAAQ,QAAO,mBAAkB;AAEzC,OAAO,MAAMC,QAAQD,SAAS,oBAAmB"}

package/dist/utils/promiseWithResolvers.js

@@ -0,0 +1,16 @@
+export const promiseWithResolvers = // @ts-expect-error TODO: replace with `Promise.withResolvers()` once it lands in node
+Promise.withResolvers?.bind(Promise) || function promiseWithResolvers() {
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej)=>{
+        resolve = res;
+        reject = rej;
+    });
+    return {
+        promise,
+        reject,
+        resolve
+    };
+};
+
+//# sourceMappingURL=promiseWithResolvers.js.map

package/dist/utils/promiseWithResolvers.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/promiseWithResolvers.ts"],"sourcesContent":["export const promiseWithResolvers =\n  // @ts-expect-error TODO: replace with `Promise.withResolvers()` once it lands in node\n  Promise.withResolvers?.bind(Promise) ||\n  function promiseWithResolvers<T>() {\n    let resolve!: (t: T) => void\n    let reject!: (err: unknown) => void\n    const promise = new Promise<T>((res, rej) => {\n      resolve = res\n      reject = rej\n    })\n    return {promise, reject, resolve}\n  }\n"],"names":["promiseWithResolvers","Promise","withResolvers","bind","resolve","reject","promise","res","rej"],"mappings":"AAAA,OAAO,MAAMA,uBACX,sFAAsF;AACtFC,QAAQC,aAAa,EAAEC,KAAKF,YAC5B,SAASD;IACP,IAAII;IACJ,IAAIC;IACJ,MAAMC,UAAU,IAAIL,QAAW,CAACM,KAAKC;QACnCJ,UAAUG;QACVF,SAASG;IACX;IACA,OAAO;QAACF;QAASD;QAAQD;IAAO;AAClC,EAAC"}

package/dist/utils/telemetryLogger.js

@@ -0,0 +1,17 @@
+/**
+ * TODO: Remove once we have a proper telemetry logger through the `@sanity/cli-core`
+ *
+ * This logger does nothing, except provide the interface to interact with
+ */ import { createBatchedStore, createSessionId } from '@sanity/telemetry';
+const session = createSessionId();
+const store = createBatchedStore(session, {
+    async resolveConsent () {
+        return {
+            status: 'denied'
+        };
+    },
+    sendEvents: async ()=>{}
+});
+export const telemetry = store.logger;
+
+//# sourceMappingURL=telemetryLogger.js.map

package/dist/utils/telemetryLogger.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/telemetryLogger.ts"],"sourcesContent":["/**\n * TODO: Remove once we have a proper telemetry logger through the `@sanity/cli-core`\n *\n * This logger does nothing, except provide the interface to interact with\n */\n\nimport {createBatchedStore, createSessionId} from '@sanity/telemetry'\n\nconst session = createSessionId()\nconst store = createBatchedStore(session, {\n  async resolveConsent() {\n    return {status: 'denied'}\n  },\n  sendEvents: async () => {},\n})\n\nexport const telemetry = store.logger\n"],"names":["createBatchedStore","createSessionId","session","store","resolveConsent","status","sendEvents","telemetry","logger"],"mappings":"AAAA;;;;CAIC,GAED,SAAQA,kBAAkB,EAAEC,eAAe,QAAO,oBAAmB;AAErE,MAAMC,UAAUD;AAChB,MAAME,QAAQH,mBAAmBE,SAAS;IACxC,MAAME;QACJ,OAAO;YAACC,QAAQ;QAAQ;IAC1B;IACAC,YAAY,WAAa;AAC3B;AAEA,OAAO,MAAMC,YAAYJ,MAAMK,MAAM,CAAA"}

package/dist/utils/test/testLongRunning.js

@@ -0,0 +1,67 @@
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { once } from 'lodash-es';
+const BIN = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../../bin/run.js');
+const isAssertionError = (e)=>e instanceof Error && e.name === 'AssertionError';
+export async function testLongRunning(command, opts) {
+    const { cwd = process.cwd(), expect: assertion, interval = 150, timeout = 20_000 } = opts;
+    let stderr = '', stdout = '';
+    // spawn command in child process
+    const child = spawn('node', [
+        BIN,
+        ...command
+    ], {
+        cwd,
+        env: {
+            ...process.env,
+            NO_COLOR: '1'
+        },
+        stdio: [
+            'pipe',
+            'pipe',
+            'pipe'
+        ]
+    });
+    // track err and out
+    child.stdout?.on('data', (d)=>stdout += d);
+    child.stderr?.on('data', (d)=>stderr += d);
+    const kill = once(()=>child.kill('SIGTERM'));
+    // track errors from the child process
+    let exitError = null;
+    child.on('exit', (code)=>{
+        if (code === 0) return;
+        exitError = new Error(`Process exited with code ${code}\nstderr: ${stderr}`);
+    });
+    child.on('error', (e)=>{
+        exitError = e;
+    });
+    // assert once every interval until expectation met, error or timeout
+    const start = Date.now();
+    async function assertExpectation() {
+        if (exitError) throw exitError;
+        try {
+            await assertion({
+                stderr,
+                stdout
+            });
+            return {
+                stderr,
+                stdout
+            };
+        } catch (e) {
+            if (!isAssertionError(e)) throw e;
+            if (Date.now() - start > timeout) throw e;
+            return new Promise((resolve)=>{
+                setTimeout(()=>resolve(assertExpectation()), interval);
+            });
+        }
+    }
+    try {
+        return await assertExpectation();
+    } finally{
+        kill();
+    }
+}
+
+//# sourceMappingURL=testLongRunning.js.map

package/dist/utils/test/testLongRunning.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utils/test/testLongRunning.ts"],"sourcesContent":["import {spawn} from 'node:child_process'\nimport path from 'node:path'\nimport {fileURLToPath} from 'node:url'\n\nimport {once} from 'lodash-es'\n\nconst BIN = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../../bin/run.js')\n\ninterface Options {\n  expect: (o: {stderr: string; stdout: string}) => Promise<void> | void\n\n  cwd?: string\n  interval?: number\n  timeout?: number\n}\n\nconst isAssertionError = (e: unknown) => e instanceof Error && e.name === 'AssertionError'\n\nexport async function testLongRunning(\n  command: string[],\n  opts: Options,\n): Promise<{stderr: string; stdout: string}> {\n  const {cwd = process.cwd(), expect: assertion, interval = 150, timeout = 20_000} = opts\n  let stderr = '',\n    stdout = ''\n\n  // spawn command in child process\n  const child = spawn('node', [BIN, ...command], {\n    cwd,\n    env: {...process.env, NO_COLOR: '1'},\n    stdio: ['pipe', 'pipe', 'pipe'],\n  })\n\n  // track err and out\n  child.stdout?.on('data', (d) => (stdout += d))\n  child.stderr?.on('data', (d) => (stderr += d))\n\n  const kill = once(() => child.kill('SIGTERM'))\n\n  // track errors from the child process\n  let exitError: Error | null = null\n  child.on('exit', (code) => {\n    if (code === 0) return\n    exitError = new Error(`Process exited with code ${code}\\nstderr: ${stderr}`)\n  })\n\n  child.on('error', (e) => {\n    exitError = e\n  })\n\n  // assert once every interval until expectation met, error or timeout\n  const start = Date.now()\n  async function assertExpectation(): Promise<{stderr: string; stdout: string}> {\n    if (exitError) throw exitError\n\n    try {\n      await assertion({stderr, stdout})\n      return {stderr, stdout}\n    } catch (e) {\n      if (!isAssertionError(e)) throw e\n      if (Date.now() - start > timeout) throw e\n\n      return new Promise((resolve) => {\n        setTimeout(() => resolve(assertExpectation()), interval)\n      })\n    }\n  }\n\n  try {\n    return await assertExpectation()\n  } finally {\n    kill()\n  }\n}\n"],"names":["spawn","path","fileURLToPath","once","BIN","resolve","dirname","url","isAssertionError","e","Error","name","testLongRunning","command","opts","cwd","process","expect","assertion","interval","timeout","stderr","stdout","child","env","NO_COLOR","stdio","on","d","kill","exitError","code","start","Date","now","assertExpectation","Promise","setTimeout"],"mappings":"AAAA,SAAQA,KAAK,QAAO,qBAAoB;AACxC,OAAOC,UAAU,YAAW;AAC5B,SAAQC,aAAa,QAAO,WAAU;AAEtC,SAAQC,IAAI,QAAO,YAAW;AAE9B,MAAMC,MAAMH,KAAKI,OAAO,CAACJ,KAAKK,OAAO,CAACJ,cAAc,YAAYK,GAAG,IAAI;AAUvE,MAAMC,mBAAmB,CAACC,IAAeA,aAAaC,SAASD,EAAEE,IAAI,KAAK;AAE1E,OAAO,eAAeC,gBACpBC,OAAiB,EACjBC,IAAa;IAEb,MAAM,EAACC,MAAMC,QAAQD,GAAG,EAAE,EAAEE,QAAQC,SAAS,EAAEC,WAAW,GAAG,EAAEC,UAAU,MAAM,EAAC,GAAGN;IACnF,IAAIO,SAAS,IACXC,SAAS;IAEX,iCAAiC;IACjC,MAAMC,QAAQvB,MAAM,QAAQ;QAACI;WAAQS;KAAQ,EAAE;QAC7CE;QACAS,KAAK;YAAC,GAAGR,QAAQQ,GAAG;YAAEC,UAAU;QAAG;QACnCC,OAAO;YAAC;YAAQ;YAAQ;SAAO;IACjC;IAEA,oBAAoB;IACpBH,MAAMD,MAAM,EAAEK,GAAG,QAAQ,CAACC,IAAON,UAAUM;IAC3CL,MAAMF,MAAM,EAAEM,GAAG,QAAQ,CAACC,IAAOP,UAAUO;IAE3C,MAAMC,OAAO1B,KAAK,IAAMoB,MAAMM,IAAI,CAAC;IAEnC,sCAAsC;IACtC,IAAIC,YAA0B;IAC9BP,MAAMI,EAAE,CAAC,QAAQ,CAACI;QAChB,IAAIA,SAAS,GAAG;QAChBD,YAAY,IAAIpB,MAAM,CAAC,yBAAyB,EAAEqB,KAAK,UAAU,EAAEV,QAAQ;IAC7E;IAEAE,MAAMI,EAAE,CAAC,SAAS,CAAClB;QACjBqB,YAAYrB;IACd;IAEA,qEAAqE;IACrE,MAAMuB,QAAQC,KAAKC,GAAG;IACtB,eAAeC;QACb,IAAIL,WAAW,MAAMA;QAErB,IAAI;YACF,MAAMZ,UAAU;gBAACG;gBAAQC;YAAM;YAC/B,OAAO;gBAACD;gBAAQC;YAAM;QACxB,EAAE,OAAOb,GAAG;YACV,IAAI,CAACD,iBAAiBC,IAAI,MAAMA;YAChC,IAAIwB,KAAKC,GAAG,KAAKF,QAAQZ,SAAS,MAAMX;YAExC,OAAO,IAAI2B,QAAQ,CAAC/B;gBAClBgC,WAAW,IAAMhC,QAAQ8B,sBAAsBhB;YACjD;QACF;IACF;IAEA,IAAI;QACF,OAAO,MAAMgB;IACf,SAAU;QACRN;IACF;AACF"}

package/oclif.manifest.json

@@ -3,7 +3,7 @@
     "typegen:generate": {
       "aliases": [],
       "args": {},
-      "description": "Sanity TypeGen (Beta)\nThis command is currently in beta and may undergo significant changes. Feedback is welcome!\n\nConfiguration:\nThis command can utilize configuration settings defined in a `sanity-typegen.json` file. These settings include:\n\n- \"path\": Specifies a glob pattern to locate your TypeScript or JavaScript files.\n  Default: \"./src/**/*.{ts,tsx,js,jsx}\"\n\n- \"schema\": Defines the path to your Sanity schema file. This file should be generated using the `sanity schema extract` command.\n  Default: \"schema.json\"\n\n- \"generates\": Indicates the path where the generated TypeScript type definitions will be saved.\n  Default: \"./sanity.types.ts\"\n\nThe default configuration values listed above are used if not overridden in your `sanity-typegen.json` configuration file. To customize the behavior of the type generation, adjust these properties in the configuration file according to your project's needs.\n\nNote:\n- The `sanity schema extract` command is a prerequisite for extracting your Sanity Studio schema into a `schema.json` file, which is then used by the `sanity typegen generate` command to generate type definitions.\n- While this tool is in beta, we encourage you to experiment with these configurations and provide feedback to help improve its functionality and usability.",
+      "description": "Sanity TypeGen (Beta)\nThis command is currently in beta and may undergo significant changes. Feedback is welcome!\n\n\u001b[1mConfiguration:\u001b[22m\nThis command can utilize configuration settings defined in a `sanity-typegen.json` file. These settings include:\n\n- \"path\": Specifies a glob pattern to locate your TypeScript or JavaScript files.\n  Default: \"./src/**/*.{ts,tsx,js,jsx}\"\n\n- \"schema\": Defines the path to your Sanity schema file. This file should be generated using the `sanity schema extract` command.\n  Default: \"schema.json\"\n\n- \"generates\": Indicates the path where the generated TypeScript type definitions will be saved.\n  Default: \"./sanity.types.ts\"\n\nThe default configuration values listed above are used if not overridden in your `sanity-typegen.json` configuration file. To customize the behavior of the type generation, adjust these properties in the configuration file according to your project's needs.\n\n\u001b[1mNote:\u001b[22m\n- The `sanity schema extract` command is a prerequisite for extracting your Sanity Studio schema into a `schema.json` file, which is then used by the `sanity typegen generate` command to generate type definitions.\n- While this tool is in beta, we encourage you to experiment with these configurations and provide feedback to help improve its functionality and usability.",
       "examples": [
         {
           "command": "<%= config.bin %> <%= command.id %>",
@@ -17,6 +17,12 @@
           "hasDynamicHelp": false,
           "multiple": false,
           "type": "option"
+        },
+        "watch": {
+          "description": "[Default: false] Run the typegen in watch mode",
+          "name": "watch",
+          "allowNo": false,
+          "type": "boolean"
         }
       },
       "hasDynamicHelp": false,
@@ -35,5 +41,5 @@
       ]
     }
   },
-  "version": "5.7.2"
+  "version": "5.9.0-watch-mode.1"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanity/codegen",
-  "version": "5.7.2",
+  "version": "5.9.0-watch-mode.1",
   "description": "Codegen toolkit for Sanity.io",
   "keywords": [
     "sanity",
@@ -24,12 +24,13 @@
   "type": "module",
   "exports": {
     ".": {
+      "types": "./dist/index.d.ts",
       "source": "./src/_exports/index.ts",
-      "default": "./dist/index.js"
+      "default": "./dist/_exports/index.js"
     },
     "./package.json": "./package.json"
   },
-  "main": "./dist/index.cjs",
+  "main": "./dist/_exports/index.js",
   "types": "./dist/index.d.ts",
   "bin": {
     "sanity-typegen": "./bin/run.js"
@@ -53,16 +54,19 @@
     "@oclif/core": "^4.8.0",
     "@oclif/plugin-help": "^6.2.36",
     "@sanity/cli-core": "^0.1.0-alpha.8",
+    "@sanity/telemetry": "^0.8.1",
     "@sanity/worker-channels": "^1.1.0",
     "debug": "^4.4.3",
     "globby": "^11.1.0",
     "groq": "^5.2.0",
     "groq-js": "^1.25.0",
     "json5": "^2.2.3",
+    "lodash-es": "^4.17.23",
     "prettier": "^3.7.4",
     "reselect": "^5.1.1",
     "tsconfig-paths": "^4.2.0",
-    "zod": "^4.3.6"
+    "zod": "^4.3.6",
+    "chokidar": "^3.6.0"
   },
   "devDependencies": {
     "@eslint/compat": "^2.0.1",
@@ -77,9 +81,9 @@
     "@types/babel__register": "^7.17.3",
     "@types/babel__traverse": "^7.28.0",
     "@types/debug": "^4.1.12",
+    "@types/lodash-es": "^4.17.12",
     "@types/node": "^20.19.28",
     "@vitest/coverage-istanbul": "^4.0.17",
-    "chokidar": "^5.0.0",
     "eslint": "^9.39.2",
     "husky": "^9.1.7",
     "lint-staged": "^16.2.7",