chore(codegen): add total types and align telemetry prop names (#6077)

Author: sgulseth

packages/sanity/src/_internal/cli/actions/typegen/generate.telemetry.ts

@@ -2,11 +2,12 @@ import {defineTrace} from '@sanity/telemetry'
 
 interface TypesGeneratedTraceAttrubutes {
   outputSize: number
-  queryTypes: number
-  schemaTypes: number
-  files: number
+  queriesCount: number
+  schemaTypesCount: number
+  queryFilesCount: number
   filesWithErrors: number
-  unknownTypes: number
+  typeNodesGenerated: number
+  unknownTypeNodesGenerated: number
 }
 
 export const TypesGeneratedTrace = defineTrace<TypesGeneratedTraceAttrubutes>({

packages/sanity/src/_internal/cli/actions/typegen/generateAction.ts

@@ -77,11 +77,12 @@ export default async function typegenGenerateAction(
   typeFile.write(generatedFileWarning)
 
   const stats = {
-    files: 0,
+    queryFilesCount: 0,
     errors: 0,
-    queries: 0,
-    schemas: 0,
-    unknownTypes: 0,
+    queriesCount: 0,
+    schemaTypesCount: 0,
+    unknownTypeNodesGenerated: 0,
+    typeNodesGenerated: 0,
     size: 0,
   }
 
@@ -108,19 +109,26 @@ export default async function typegenGenerateAction(
       let fileTypeString = `// Source: ${msg.filename}\n`
 
       if (msg.type === 'schema') {
-        stats.schemas += msg.length
+        stats.schemaTypesCount += msg.length
         fileTypeString += `${msg.schema}\n\n`
         typeFile.write(fileTypeString)
         return
       }
 
-      stats.files++
-      for (const {queryName, query, type, unknownTypes} of msg.types) {
+      stats.queryFilesCount++
+      for (const {
+        queryName,
+        query,
+        type,
+        typeNodesGenerated,
+        unknownTypeNodesGenerated,
+      } of msg.types) {
         fileTypeString += `// Variable: ${queryName}\n`
         fileTypeString += `// Query: ${query.replace(/(\r\n|\n|\r)/gm, '')}\n`
         fileTypeString += `${type}\n`
-        stats.queries++
-        stats.unknownTypes += unknownTypes
+        stats.queriesCount++
+        stats.typeNodesGenerated += typeNodesGenerated
+        stats.unknownTypeNodesGenerated += unknownTypeNodesGenerated
       }
       typeFile.write(`${fileTypeString}\n`)
       stats.size += Buffer.byteLength(fileTypeString)
@@ -132,11 +140,12 @@ export default async function typegenGenerateAction(
 
   trace.log({
     outputSize: stats.size,
-    queryTypes: stats.queries,
-    schemaTypes: stats.schemas,
-    files: stats.files,
+    queriesCount: stats.queriesCount,
+    schemaTypesCount: stats.schemaTypesCount,
+    queryFilesCount: stats.queryFilesCount,
     filesWithErrors: stats.errors,
-    unknownTypes: stats.unknownTypes,
+    typeNodesGenerated: stats.typeNodesGenerated,
+    unknownTypeNodesGenerated: stats.unknownTypeNodesGenerated,
   })
 
   trace.complete()
@@ -145,6 +154,6 @@ export default async function typegenGenerateAction(
   }
 
   spinner.succeed(
-    `Generated TypeScript types for ${stats.schemas} schema types and ${stats.queries} GROQ queries in ${stats.files} files into: ${codegenConfig.generates}`,
+    `Generated TypeScript types for ${stats.schemaTypesCount} schema types and ${stats.queriesCount} GROQ queries in ${stats.queryFilesCount} files into: ${codegenConfig.generates}`,
   )
 }

packages/sanity/src/_internal/cli/threads/typegenGenerate.ts

@@ -33,7 +33,8 @@ export type TypegenGenerateTypesWorkerMessage =
         queryName: string
         query: string
         type: string
-        unknownTypes: number
+        unknownTypeNodesGenerated: number
+        typeNodesGenerated: number
       }[]
     }
   | {
@@ -88,20 +89,27 @@ async function main() {
     }
     $info(`Processing ${result.queries.length} queries in "${result.filename}"...`)
 
-    const fileQueryTypes: {queryName: string; query: string; type: string; unknownTypes: number}[] =
-      []
+    const fileQueryTypes: {
+      queryName: string
+      query: string
+      type: string
+      unknownTypeNodesGenerated: number
+      typeNodesGenerated: number
+    }[] = []
     for (const {name: queryName, result: query} of result.queries) {
       try {
         const ast = parse(query)
         const queryTypes = typeEvaluate(ast, schema)
 
         const type = typeGenerator.generateTypeNodeTypes(`${queryName}Result`, queryTypes)
 
+        const queryTypeStats = walkAndCountQueryTypeNodeStats(queryTypes)
         fileQueryTypes.push({
           queryName,
           query,
           type,
-          unknownTypes: countUnknownTypes(queryTypes),
+          unknownTypeNodesGenerated: queryTypeStats.unknownTypes,
+          typeNodesGenerated: queryTypeStats.allTypes,
         })
       } catch (err) {
         parentPort?.postMessage({
@@ -131,29 +139,46 @@ async function main() {
   } satisfies TypegenGenerateTypesWorkerMessage)
 }
 
-function countUnknownTypes(typeNode: TypeNode): number {
+function walkAndCountQueryTypeNodeStats(typeNode: TypeNode): {
+  allTypes: number
+  unknownTypes: number
+} {
   switch (typeNode.type) {
-    case 'unknown':
-      return 1
-    case 'array':
-      return countUnknownTypes(typeNode.of)
-    case 'object':
+    case 'unknown': {
+      return {allTypes: 1, unknownTypes: 1}
+    }
+    case 'array': {
+      const acc = walkAndCountQueryTypeNodeStats(typeNode.of)
+      acc.allTypes += 1 // count the array type itself
+      return acc
+    }
+    case 'object': {
       // if the rest is unknown, we count it as one unknown type
       if (typeNode.rest && typeNode.rest.type === 'unknown') {
-        return 1
+        return {allTypes: 2, unknownTypes: 1} // count the object type itself as well
       }
 
-      return (
-        Object.values(typeNode.attributes).reduce(
-          (acc, attribute) => acc + countUnknownTypes(attribute.value),
-          0,
-        ) + (typeNode.rest ? countUnknownTypes(typeNode.rest) : 0)
-      )
-    case 'union':
-      return typeNode.of.reduce((acc, type) => acc + countUnknownTypes(type), 0)
+      const restStats = typeNode.rest
+        ? walkAndCountQueryTypeNodeStats(typeNode.rest)
+        : {allTypes: 1, unknownTypes: 0} // count the object type itself
 
-    default:
-      return 0
+      return Object.values(typeNode.attributes).reduce((acc, attribute) => {
+        const {allTypes, unknownTypes} = walkAndCountQueryTypeNodeStats(attribute.value)
+        return {allTypes: acc.allTypes + allTypes, unknownTypes: acc.unknownTypes + unknownTypes}
+      }, restStats)
+    }
+    case 'union': {
+      return typeNode.of.reduce(
+        (acc, type) => {
+          const {allTypes, unknownTypes} = walkAndCountQueryTypeNodeStats(type)
+          return {allTypes: acc.allTypes + allTypes, unknownTypes: acc.unknownTypes + unknownTypes}
+        },
+        {allTypes: 1, unknownTypes: 0}, // count the union type itself
+      )
+    }
+    default: {
+      return {allTypes: 1, unknownTypes: 0}
+    }
   }
 }