@sanity/codegen 5.0.0-next-major.12 → 5.0.0-next-major.14

package/lib/index.js

@@ -1,7 +1,7 @@
 import fs$1, { readFile } from "node:fs/promises";
 import json5 from "json5";
 import * as z from "zod";
-import { parse } from "groq-js";
+import { parse, typeEvaluate } from "groq-js";
 import createDebug from "debug";
 import glob from "globby";
 import fs, { existsSync } from "node:fs";
@@ -13,6 +13,8 @@ import * as t from "@babel/types";
 import traverse, { Scope } from "@babel/traverse";
 import { loadConfig, createMatchPath } from "tsconfig-paths";
 import register from "@babel/register";
+import process from "node:process";
+import { createSelector } from "reselect";
 import { CodeGenerator } from "@babel/generator";
 const configDefinition = z.object({
   path: z.string().or(z.array(z.string())).default([
@@ -417,9 +419,28 @@ function resolveExportSpecifier({
     cause: `noBinding:${importName}`
   });
 }
+const isRecord = (value) => (typeof value == "object" || typeof value == "function") && !!value;
+class QueryExtractionError extends Error {
+  variable;
+  filename;
+  constructor({ variable, cause, filename }) {
+    super(
+      `Error while extracting query ${variable ? `from variable '${variable.id.name}' ` : ""}in ${filename}: ${isRecord(cause) && typeof cause.message == "string" ? cause.message : "Unknown error"}`
+    ), this.name = "QueryExtractionError", this.cause = cause, this.variable = variable, this.filename = filename;
+  }
+}
+class QueryEvaluationError extends Error {
+  variable;
+  filename;
+  constructor({ variable, cause, filename }) {
+    super(
+      `Error while evaluating query ${variable ? `from variable '${variable.id.name}' ` : ""}in ${filename}: ${isRecord(cause) && typeof cause.message == "string" ? cause.message : "Unknown error"}`
+    ), this.name = "QueryEvaluationError", this.cause = cause, this.variable = variable, this.filename = filename;
+  }
+}
 const __filename$1 = fileURLToPath(import.meta.url), require$2 = createRequire(__filename$1), groqTagName = "groq", defineQueryFunctionName = "defineQuery", groqModuleName = "groq", nextSanityModuleName = "next-sanity", ignoreValue = "@sanity-typegen-ignore";
 function findQueriesInSource(source, filename, babelConfig = getBabelConfig(), resolver = require$2.resolve) {
-  const queries = [], file = parseSourceFile(source, filename, babelConfig);
+  const queries = [], errors = [], file = parseSourceFile(source, filename, babelConfig);
   return traverse$1(file, {
     // Look for variable declarations, e.g. `const myQuery = groq`... and extract the query.
     // The variable name is used as the name of the query result type
@@ -428,25 +449,23 @@ function findQueriesInSource(source, filename, babelConfig = getBabelConfig(), r
       if (t.isIdentifier(node.id) && (isGroqTemplateTag || isDefineQueryCall)) {
         if (declarationLeadingCommentContains(path2, ignoreValue))
           return;
-        const queryName = `${node.id.name}`, queryResult = resolveExpression({
-          node: init,
-          file,
-          scope,
-          babelConfig,
-          filename,
-          resolver
-        }), location = node.loc ? {
-          start: {
-            ...node.loc?.start
-          },
-          end: {
-            ...node.loc?.end
-          }
-        } : {};
-        queries.push({ name: queryName, result: queryResult, location });
+        const { id, start, end } = node, variable = { id, ...start && { start }, ...end && { end } };
+        try {
+          const query = resolveExpression({
+            node: init,
+            file,
+            scope,
+            babelConfig,
+            filename,
+            resolver
+          });
+          queries.push({ variable, query, filename });
+        } catch (cause) {
+          errors.push(new QueryExtractionError({ filename, variable, cause }));
+        }
       }
     }
-  }), queries;
+  }), { filename, queries, errors };
 }
 function declarationLeadingCommentContains(path2, comment) {
   const variableDeclaration = path2.find((node) => node.isVariableDeclaration());
@@ -498,7 +517,7 @@ function getResolver(cwd) {
   return resolve2.paths = (request) => require$1.resolve.paths(request), resolve2;
 }
 const debug = createDebug("sanity:codegen:findQueries:debug");
-async function* findQueriesInPath({
+function findQueriesInPath({
   path: path2,
   babelOptions = getBabelConfig(),
   resolver = getResolver()
@@ -511,138 +530,105 @@ async function* findQueriesInPath({
     // we never want to look in node_modules
     onlyFiles: !0
   }).sort();
-  for (const filename of files)
-    if (typeof filename == "string") {
-      debug(`Found file "${filename}"`);
-      try {
-        const source = await fs$1.readFile(filename, "utf8"), queries = findQueriesInSource(source, filename, babelOptions, resolver);
-        for (const query of queries) {
-          if (queryNames.has(query.name))
-            throw new Error(
-              `Duplicate query name found: "${query.name}". Query names must be unique across all files.`
-            );
-          queryNames.add(query.name);
+  async function* getQueries() {
+    for (const filename of files)
+      if (typeof filename == "string") {
+        debug(`Found file "${filename}"`);
+        try {
+          const source = await fs$1.readFile(filename, "utf8"), pluckedModuleResult = findQueriesInSource(source, filename, babelOptions, resolver);
+          for (const { variable } of pluckedModuleResult.queries) {
+            if (queryNames.has(variable.id.name))
+              throw new Error(
+                `Duplicate query name found: "${variable.id.name}". Query names must be unique across all files.`
+              );
+            queryNames.add(variable.id.name);
+          }
+          yield pluckedModuleResult;
+        } catch (cause) {
+          debug(`Error in file "${filename}"`, cause), yield {
+            filename,
+            queries: [],
+            errors: [new QueryExtractionError({ cause, filename })]
+          };
         }
-        yield { type: "queries", filename, queries };
-      } catch (error) {
-        debug(`Error in file "${filename}"`, error), yield { type: "error", error, filename };
       }
-    }
+  }
+  return { files, queries: getQueries() };
 }
 function registerBabel(babelOptions) {
   const options = babelOptions || getBabelConfig();
   register({ ...options, extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"] });
 }
-const REFERENCE_SYMBOL_NAME = "internalGroqTypeReferenceTo", ALL_SCHEMA_TYPES = "AllSanitySchemaTypes";
-class TypeGenerator {
-  // Simple set to keep track of generated type names, to avoid conflicts
-  generatedTypeName = /* @__PURE__ */ new Set();
-  // Map between type names and their generated type names, used to resolve the correct generated type name
-  typeNameMap = /* @__PURE__ */ new Map();
-  // Map between type nodes and their generated type names, used for query mapping
-  typeNodeNameMap = /* @__PURE__ */ new Map();
+function resultSuffix(variableName) {
+  if (!variableName) return "result";
+  const isUpperSnake = /^[A-Z0-9_]+$/.test(variableName), isSnake = /^[a-z0-9_]+$/.test(variableName) && variableName.includes("_");
+  return /^[a-z][A-Za-z0-9]*$/.test(variableName) ? `${variableName}Result` : isUpperSnake ? `${variableName}_RESULT` : isSnake ? `${variableName}_result` : `${variableName.replace(/[^A-Za-z0-9]/g, "")}Result`;
+}
+const INTERNAL_REFERENCE_SYMBOL = t.identifier("internalGroqTypeReferenceTo"), ALL_SANITY_SCHEMA_TYPES = t.identifier("AllSanitySchemaTypes"), SANITY_QUERIES = t.identifier("SanityQueries"), RESERVED_IDENTIFIERS = /* @__PURE__ */ new Set();
+RESERVED_IDENTIFIERS.add(SANITY_QUERIES.name);
+RESERVED_IDENTIFIERS.add(ALL_SANITY_SCHEMA_TYPES.name);
+RESERVED_IDENTIFIERS.add(INTERNAL_REFERENCE_SYMBOL.name);
+function normalizePath(root, filename) {
+  const resolved = path.resolve(root, filename);
+  return path.relative(root, resolved);
+}
+function sanitizeIdentifier(input) {
+  return `${input.replace(/^\d/, "_").replace(/[^$\w]+(.)/g, (_, char) => char.toUpperCase())}`;
+}
+function normalizeIdentifier(input) {
+  const sanitized = sanitizeIdentifier(input);
+  return `${sanitized.charAt(0).toUpperCase()}${sanitized.slice(1)}`;
+}
+function getUniqueIdentifierForName(name, currentIdentifiers) {
+  const desiredName = normalizeIdentifier(name);
+  let resultingName = desiredName, index = 2;
+  for (; currentIdentifiers.has(resultingName) || RESERVED_IDENTIFIERS.has(resultingName); )
+    resultingName = `${desiredName}_${index}`, index++;
+  return t.identifier(resultingName);
+}
+function computeOnce(fn) {
+  const ref = { current: void 0, computed: !1 };
+  return function() {
+    return ref.computed || (ref.current = fn(), ref.computed = !0), ref.current;
+  };
+}
+function weakMapMemo(fn) {
+  const cache = /* @__PURE__ */ new WeakMap();
+  return function(arg) {
+    if (cache.has(arg)) return cache.get(arg);
+    const result = fn(arg);
+    return cache.set(arg, result), result;
+  };
+}
+function generateCode(node) {
+  return `${new CodeGenerator(node).generate().code.trim()}
+
+`;
+}
+class SchemaTypeGenerator {
   schema;
+  tsTypes = /* @__PURE__ */ new Map();
+  identifiers = /* @__PURE__ */ new Map();
   constructor(schema) {
-    this.schema = schema, this.schema.forEach((s) => {
-      this.getTypeName(s.name, s);
-    });
-  }
-  /**
-   * Generate TypeScript types for the given schema
-   * @returns string
-   * @internal
-   * @beta
-   */
-  generateSchemaTypes() {
-    const typeDeclarations = [], schemaNames = /* @__PURE__ */ new Set();
-    return this.schema.forEach((schema) => {
-      const typeLiteral = this.getTypeNodeType(schema), schemaName = this.typeNodeNameMap.get(schema);
-      if (!schemaName)
-        throw new Error(`Schema name not found for schema ${schema.name}`);
-      schemaNames.add(schemaName);
-      const typeAlias = t.tsTypeAliasDeclaration(t.identifier(schemaName), null, typeLiteral);
-      typeDeclarations.push(t.exportNamedDeclaration(typeAlias));
-    }), typeDeclarations.push(
-      t.exportNamedDeclaration(
-        t.tsTypeAliasDeclaration(
-          t.identifier(this.getTypeName(ALL_SCHEMA_TYPES)),
-          null,
-          t.tsUnionType(
-            [...schemaNames].map((typeName) => t.tsTypeReference(t.identifier(typeName)))
-          )
-        )
-      )
-    ), typeDeclarations.map((decl) => new CodeGenerator(decl).generate().code).join(`
-
-`);
-  }
-  /**
-   * Takes a identifier and a type node and generates a type alias for the type node.
-   * @param identifierName - The name of the type to generated
-   * @param typeNode - The type node to generate the type for
-   * @returns
-   * @internal
-   * @beta
-   */
-  generateTypeNodeTypes(identifierName, typeNode) {
-    const type = this.getTypeNodeType(typeNode), typeName = this.getTypeName(identifierName, typeNode), typeAlias = t.tsTypeAliasDeclaration(t.identifier(typeName), null, type);
-    return new CodeGenerator(t.exportNamedDeclaration(typeAlias)).generate().code.trim();
-  }
-  static generateKnownTypes() {
-    const typeOperator = t.tsTypeOperator(t.tsSymbolKeyword(), "unique"), identifier = t.identifier(REFERENCE_SYMBOL_NAME);
-    identifier.typeAnnotation = t.tsTypeAnnotation(typeOperator);
-    const decleration = t.variableDeclaration("const", [t.variableDeclarator(identifier)]);
-    return decleration.declare = !0, new CodeGenerator(t.exportNamedDeclaration(decleration)).generate().code.trim();
-  }
-  /**
-   * Takes a list of queries from the codebase and generates a type declaration
-   * for SanityClient to consume.
-   *
-   * Note: only types that have previously been generated with `generateTypeNodeTypes`
-   * will be included in the query map.
-   *
-   * @param queries - A list of queries to generate a type declaration for
-   * @returns
-   * @internal
-   * @beta
-   */
-  generateQueryMap(queries) {
-    const typesByQuerystring = {};
-    for (const query of queries) {
-      const name = this.typeNodeNameMap.get(query.typeNode);
-      name && (typesByQuerystring[query.query] ??= [], typesByQuerystring[query.query].push(name));
+    this.schema = schema;
+    const uniqueTypeNames = /* @__PURE__ */ new Set();
+    for (const type of schema) {
+      if (uniqueTypeNames.has(type.name))
+        throw new Error(
+          `Duplicate type name "${type.name}" in schema. Type names must be unique within the same schema.`
+        );
+      uniqueTypeNames.add(type.name);
     }
-    const queryReturnInterface = t.tsInterfaceDeclaration(
-      t.identifier("SanityQueries"),
-      null,
-      [],
-      t.tsInterfaceBody(
-        Object.entries(typesByQuerystring).map(([query, types]) => t.tsPropertySignature(
-          t.stringLiteral(query),
-          t.tsTypeAnnotation(
-            t.tsUnionType(types.map((type) => t.tsTypeReference(t.identifier(type))))
-          )
-        ))
-      )
-    ), declareModule = t.declareModule(
-      t.stringLiteral("@sanity/client"),
-      t.blockStatement([queryReturnInterface])
-    ), clientImport = t.importDeclaration([], t.stringLiteral("@sanity/client"));
-    return new CodeGenerator(t.program([clientImport, declareModule])).generate().code.trim();
-  }
-  /**
-   * Since we are sanitizing identifiers we migt end up with collisions. Ie there might be a type mux.video and muxVideo, both these
-   * types would be sanityized into MuxVideo. To avoid this we keep track of the generated type names and add a index to the name.
-   * When we reference a type we also keep track of the original name so we can reference the correct type later.
-   */
-  getTypeName(name, typeNode) {
-    const desiredName = uppercaseFirstLetter(sanitizeIdentifier(name));
-    let generatedName = desiredName, i = 2;
-    for (; this.generatedTypeName.has(generatedName); )
-      generatedName = `${desiredName}_${i++}`;
-    return this.generatedTypeName.add(generatedName), this.typeNameMap.set(name, generatedName), typeNode && this.typeNodeNameMap.set(typeNode, generatedName), generatedName;
+    for (const type of schema) {
+      const currentIdentifierNames = new Set(
+        Array.from(this.identifiers.values()).map((id) => id.name)
+      ), uniqueIdentifier = getUniqueIdentifierForName(type.name, currentIdentifierNames);
+      this.identifiers.set(type.name, uniqueIdentifier);
+    }
+    for (const type of schema)
+      this.tsTypes.set(type.name, this.generateTsType(type));
   }
-  getTypeNodeType(typeNode) {
+  generateTsType(typeNode) {
     switch (typeNode.type) {
       case "string":
         return typeNode.value !== void 0 ? t.tsLiteralType(t.stringLiteral(typeNode.value)) : t.tsStringKeyword();
@@ -653,9 +639,9 @@ class TypeGenerator {
       case "unknown":
         return t.tsUnknownKeyword();
       case "document":
-        return this.generateDocumentType(typeNode);
+        return this.generateDocumentTsType(typeNode);
       case "type":
-        return this.getTypeNodeType(typeNode.value);
+        return this.generateTsType(typeNode.value);
       case "array":
         return this.generateArrayTsType(typeNode);
       case "object":
@@ -667,20 +653,20 @@ class TypeGenerator {
       case "null":
         return t.tsNullKeyword();
       default:
-        throw new Error(`Type "${typeNode.type}" not found in schema`);
+        throw new Error(
+          `Encountered unsupported node type "${// @ts-expect-error This should never happen
+          typeNode.type}" while generating schema types`
+        );
     }
   }
   // Helper function used to generate TS types for array type nodes.
   generateArrayTsType(typeNode) {
-    const typeNodes = this.getTypeNodeType(typeNode.of);
-    return t.tsTypeReference(
-      t.identifier("Array"),
-      t.tsTypeParameterInstantiation([typeNodes])
-    );
+    const typeNodes = this.generateTsType(typeNode.of);
+    return t.tsTypeReference(t.identifier("Array"), t.tsTypeParameterInstantiation([typeNodes]));
   }
   // Helper function used to generate TS types for object properties.
-  generateObjectProperty(key, attribute) {
-    const type = this.getTypeNodeType(attribute.value), propertySignature = t.tsPropertySignature(
+  generateTsObjectProperty(key, attribute) {
+    const type = this.generateTsType(attribute.value), propertySignature = t.tsPropertySignature(
       t.identifier(sanitizeIdentifier(key)),
       t.tsTypeAnnotation(type)
     );
@@ -690,16 +676,16 @@ class TypeGenerator {
   generateObjectTsType(typeNode) {
     const props = [];
     Object.entries(typeNode.attributes).forEach(([key, attribute]) => {
-      props.push(this.generateObjectProperty(key, attribute));
+      props.push(this.generateTsObjectProperty(key, attribute));
     });
     const rest = typeNode.rest;
-    if (rest !== void 0)
+    if (rest)
       switch (rest.type) {
         case "unknown":
           return t.tsUnknownKeyword();
         case "object": {
           Object.entries(rest.attributes).forEach(([key, attribute]) => {
-            props.push(this.generateObjectProperty(key, attribute));
+            props.push(this.generateTsObjectProperty(key, attribute));
           });
           break;
         }
@@ -710,56 +696,243 @@ class TypeGenerator {
         default:
           throw new Error(`Type "${rest.type}" not found in schema`);
       }
-    if (typeNode.dereferencesTo !== void 0) {
-      const derefType = t.tsPropertySignature(
-        t.identifier(REFERENCE_SYMBOL_NAME),
-        t.tsTypeAnnotation(t.tsLiteralType(t.stringLiteral(typeNode.dereferencesTo)))
+    if (typeNode.dereferencesTo) {
+      const derefType = Object.assign(
+        t.tsPropertySignature(
+          INTERNAL_REFERENCE_SYMBOL,
+          t.tsTypeAnnotation(t.tsLiteralType(t.stringLiteral(typeNode.dereferencesTo)))
+        ),
+        { computed: !0, optional: !0 }
       );
-      derefType.computed = !0, derefType.optional = !0, props.push(derefType);
+      props.push(derefType);
     }
     return t.tsTypeLiteral(props);
   }
   generateInlineTsType(typeNode) {
-    const referencedTypeNode = this.schema.find((schema) => schema.name === typeNode.name);
-    if (referencedTypeNode === void 0) {
-      const generatedName2 = this.typeNameMap.get(typeNode.name);
-      if (generatedName2)
-        return t.tsTypeReference(t.identifier(generatedName2));
-      const missing = t.tsUnknownKeyword();
-      return missing.trailingComments = [
-        {
-          type: "CommentLine",
-          value: ` Unable to locate the referenced type "${typeNode.name}" in schema`
-        }
-      ], missing;
-    }
-    const generatedName = this.typeNameMap.get(referencedTypeNode.name);
-    return generatedName ? t.tsTypeReference(t.identifier(generatedName)) : t.tsUnknownKeyword();
+    const id = this.identifiers.get(typeNode.name);
+    return id ? t.tsTypeReference(id) : t.addComment(
+      t.tsUnknownKeyword(),
+      "trailing",
+      ` Unable to locate the referenced type "${typeNode.name}" in schema`,
+      !0
+    );
   }
   // Helper function used to generate TS types for union type nodes.
   generateUnionTsType(typeNode) {
-    if (typeNode.of.length === 0)
-      return t.tsNeverKeyword();
-    if (typeNode.of.length === 1)
-      return this.getTypeNodeType(typeNode.of[0]);
-    const typeNodes = typeNode.of.map((node) => this.getTypeNodeType(node));
-    return t.tsUnionType(typeNodes);
+    return typeNode.of.length === 0 ? t.tsNeverKeyword() : typeNode.of.length === 1 ? this.generateTsType(typeNode.of[0]) : t.tsUnionType(typeNode.of.map((node) => this.generateTsType(node)));
   }
   // Helper function used to generate TS types for document type nodes.
-  generateDocumentType(document) {
+  generateDocumentTsType(document) {
     const props = Object.entries(document.attributes).map(
-      ([key, node]) => this.generateObjectProperty(key, node)
+      ([key, node]) => this.generateTsObjectProperty(key, node)
     );
     return t.tsTypeLiteral(props);
   }
+  typeNames() {
+    return this.schema.map((schemaType) => schemaType.name);
+  }
+  getType(typeName) {
+    const tsType = this.tsTypes.get(typeName), id = this.identifiers.get(typeName);
+    if (tsType && id) return { tsType, id };
+  }
+  hasType(typeName) {
+    return this.tsTypes.has(typeName);
+  }
+  evaluateQuery = weakMapMemo(
+    ({ query }) => {
+      const ast = safeParseQuery(query), typeNode = typeEvaluate(ast, this.schema), tsType = this.generateTsType(typeNode), stats = walkAndCountQueryTypeNodeStats(typeNode);
+      return { tsType, stats };
+    }
+  );
+  *[Symbol.iterator]() {
+    for (const { name } of this.schema)
+      yield { name, ...this.getType(name) };
+  }
 }
-function uppercaseFirstLetter(input) {
-  return input.charAt(0).toUpperCase() + input.slice(1);
+function walkAndCountQueryTypeNodeStats(typeNode) {
+  switch (typeNode.type) {
+    case "unknown":
+      return { allTypes: 1, unknownTypes: 1, emptyUnions: 0 };
+    case "array": {
+      const acc = walkAndCountQueryTypeNodeStats(typeNode.of);
+      return acc.allTypes += 1, acc;
+    }
+    case "object": {
+      if (typeNode.rest && typeNode.rest.type === "unknown")
+        return { allTypes: 2, unknownTypes: 1, emptyUnions: 0 };
+      const restStats = typeNode.rest ? walkAndCountQueryTypeNodeStats(typeNode.rest) : { allTypes: 0, unknownTypes: 0, emptyUnions: 0 };
+      return restStats.allTypes += 1, Object.values(typeNode.attributes).reduce((acc, attribute) => {
+        const { allTypes, unknownTypes, emptyUnions } = walkAndCountQueryTypeNodeStats(
+          attribute.value
+        );
+        return {
+          allTypes: acc.allTypes + allTypes,
+          unknownTypes: acc.unknownTypes + unknownTypes,
+          emptyUnions: acc.emptyUnions + emptyUnions
+        };
+      }, restStats);
+    }
+    case "union":
+      return typeNode.of.length === 0 ? { allTypes: 1, unknownTypes: 0, emptyUnions: 1 } : typeNode.of.reduce(
+        (acc, type) => {
+          const { allTypes, unknownTypes, emptyUnions } = walkAndCountQueryTypeNodeStats(type);
+          return {
+            allTypes: acc.allTypes + allTypes,
+            unknownTypes: acc.unknownTypes + unknownTypes,
+            emptyUnions: acc.emptyUnions + emptyUnions
+          };
+        },
+        { allTypes: 1, unknownTypes: 0, emptyUnions: 0 }
+        // count the union type itself
+      );
+    default:
+      return { allTypes: 1, unknownTypes: 0, emptyUnions: 0 };
+  }
 }
-function sanitizeIdentifier(input) {
-  return `${input.replace(/^\d/, "_").replace(/[^$\w]+(.)/g, (_, char) => char.toUpperCase())}`;
+class TypeGenerator {
+  getInternalReferenceSymbolDeclaration = computeOnce(() => {
+    const typeOperator = t.tsTypeOperator(t.tsSymbolKeyword(), "unique"), id = INTERNAL_REFERENCE_SYMBOL;
+    id.typeAnnotation = t.tsTypeAnnotation(typeOperator);
+    const declaration = t.variableDeclaration("const", [t.variableDeclarator(id)]);
+    declaration.declare = !0;
+    const ast = t.exportNamedDeclaration(declaration), code = generateCode(ast);
+    return { id, code, ast };
+  });
+  getSchemaTypeGenerator = createSelector(
+    [(options) => options.schema],
+    (schema) => new SchemaTypeGenerator(schema)
+  );
+  getSchemaTypeDeclarations = createSelector(
+    [
+      (options) => options.root,
+      (options) => options.schemaPath,
+      this.getSchemaTypeGenerator
+    ],
+    (root = process.cwd(), schemaPath, schema) => Array.from(schema).map(({ id, name, tsType }, index) => {
+      const typeAlias = t.tsTypeAliasDeclaration(id, null, tsType);
+      let ast = t.exportNamedDeclaration(typeAlias);
+      index === 0 && schemaPath && (ast = t.addComments(ast, "leading", [
+        { type: "CommentLine", value: ` Source: ${normalizePath(root, schemaPath)}` }
+      ]));
+      const code = generateCode(ast);
+      return { id, code, name, tsType, ast };
+    })
+  );
+  getAllSanitySchemaTypesDeclaration = createSelector(
+    [this.getSchemaTypeDeclarations],
+    (schemaTypes) => {
+      const ast = t.exportNamedDeclaration(
+        t.tsTypeAliasDeclaration(
+          ALL_SANITY_SCHEMA_TYPES,
+          null,
+          schemaTypes.length ? t.tsUnionType(schemaTypes.map(({ id }) => t.tsTypeReference(id))) : t.tsNeverKeyword()
+        )
+      ), code = generateCode(ast);
+      return { id: ALL_SANITY_SCHEMA_TYPES, code, ast };
+    }
+  );
+  static async getEvaluatedModules({
+    root = process.cwd(),
+    reporter: report,
+    schemaTypeGenerator,
+    schemaTypeDeclarations,
+    queries: extractedModules
+  }) {
+    if (!extractedModules)
+      return report?.stream.evaluatedModules.end(), [];
+    const currentIdentifiers = new Set(schemaTypeDeclarations.map(({ id }) => id.name)), evaluatedModuleResults = [];
+    for await (const { filename, ...extractedModule } of extractedModules) {
+      const queries = [], errors = [...extractedModule.errors];
+      for (const extractedQuery of extractedModule.queries) {
+        const { variable } = extractedQuery;
+        try {
+          const { tsType, stats } = schemaTypeGenerator.evaluateQuery(extractedQuery), id = getUniqueIdentifierForName(resultSuffix(variable.id.name), currentIdentifiers), typeAlias = t.tsTypeAliasDeclaration(id, null, tsType), trimmedQuery = extractedQuery.query.replace(/(\r\n|\n|\r)/gm, "").trim(), ast = t.addComments(t.exportNamedDeclaration(typeAlias), "leading", [
+            { type: "CommentLine", value: ` Source: ${normalizePath(root, filename)}` },
+            { type: "CommentLine", value: ` Variable: ${variable.id.name}` },
+            { type: "CommentLine", value: ` Query: ${trimmedQuery}` }
+          ]), evaluatedQueryResult = {
+            id,
+            code: generateCode(ast),
+            ast,
+            stats,
+            tsType,
+            ...extractedQuery
+          };
+          currentIdentifiers.add(id.name), queries.push(evaluatedQueryResult);
+        } catch (cause) {
+          errors.push(new QueryEvaluationError({ variable, cause, filename }));
+        }
+      }
+      const evaluatedModule = {
+        filename,
+        queries,
+        errors
+      };
+      report?.stream.evaluatedModules.emit(evaluatedModule), evaluatedModuleResults.push(evaluatedModule);
+    }
+    return report?.stream.evaluatedModules.end(), evaluatedModuleResults;
+  }
+  static async getQueryMapDeclaration({
+    overloadClientMethods = !0,
+    evaluatedModules
+  }) {
+    if (!overloadClientMethods) return { code: "", ast: t.program([]) };
+    const queries = evaluatedModules.flatMap((module) => module.queries);
+    if (!queries.length) return { code: "", ast: t.program([]) };
+    const typesByQuerystring = {};
+    for (const { id, query } of queries)
+      typesByQuerystring[query] ??= [], typesByQuerystring[query].push(id.name);
+    const queryReturnInterface = t.tsInterfaceDeclaration(
+      SANITY_QUERIES,
+      null,
+      [],
+      t.tsInterfaceBody(
+        Object.entries(typesByQuerystring).map(([query, types]) => t.tsPropertySignature(
+          t.stringLiteral(query),
+          t.tsTypeAnnotation(
+            types.length ? t.tsUnionType(types.map((type) => t.tsTypeReference(t.identifier(type)))) : t.tsNeverKeyword()
+          )
+        ))
+      )
+    ), declareModule = t.declareModule(
+      t.stringLiteral("@sanity/client"),
+      t.blockStatement([queryReturnInterface])
+    ), clientImport = t.addComments(
+      t.importDeclaration([], t.stringLiteral("@sanity/client")),
+      "leading",
+      [{ type: "CommentLine", value: " Query TypeMap" }]
+    ), ast = t.program([clientImport, declareModule]);
+    return { code: generateCode(ast), ast };
+  }
+  async generateTypes(options) {
+    const { reporter: report } = options, internalReferenceSymbol = this.getInternalReferenceSymbolDeclaration(), schemaTypeDeclarations = this.getSchemaTypeDeclarations(options), allSanitySchemaTypesDeclaration = this.getAllSanitySchemaTypesDeclaration(options);
+    report?.event.generatedSchemaTypes({
+      internalReferenceSymbol,
+      schemaTypeDeclarations,
+      allSanitySchemaTypesDeclaration
+    });
+    const program = t.program([]);
+    let code = "";
+    for (const declaration of schemaTypeDeclarations)
+      program.body.push(declaration.ast), code += declaration.code;
+    program.body.push(allSanitySchemaTypesDeclaration.ast), code += allSanitySchemaTypesDeclaration.code, program.body.push(internalReferenceSymbol.ast), code += internalReferenceSymbol.code;
+    const evaluatedModules = await TypeGenerator.getEvaluatedModules({
+      ...options,
+      schemaTypeDeclarations,
+      schemaTypeGenerator: this.getSchemaTypeGenerator(options)
+    });
+    for (const { queries } of evaluatedModules)
+      for (const query of queries)
+        program.body.push(query.ast), code += query.code;
+    const queryMapDeclaration = await TypeGenerator.getQueryMapDeclaration({
+      ...options,
+      evaluatedModules
+    });
+    return program.body.push(...queryMapDeclaration.ast.body), code += queryMapDeclaration.code, report?.event.generatedQueryTypes({ queryMapDeclaration }), { code, ast: program };
+  }
 }
 export {
+  QueryExtractionError,
   TypeGenerator,
   configDefinition,
   findQueriesInPath,