refactor(utils): fix compiler errors from recursive schema types

Author: matejchalk

packages/models/src/index.ts

@@ -132,6 +132,8 @@ export {
   type CoverageTreeMissingLOC,
   type CoverageTreeNode,
   type Tree,
+  type BasicTreeNodeValues,
+  type CoverageTreeNodeValues,
 } from './lib/tree.js';
 export { uploadConfigSchema, type UploadConfig } from './lib/upload-config.js';
 export {

packages/models/src/lib/tree.ts

@@ -5,6 +5,8 @@ const basicTreeNodeValuesSchema = z.record(
   z.string(),
   z.union([z.number(), z.string()]),
 );
+export type BasicTreeNodeValues = z.infer<typeof basicTreeNodeValuesSchema>;
+
 const basicTreeNodeDataSchema = z.object({
   name: z.string().min(1).describe('Text label for node'),
   values: basicTreeNodeValuesSchema
@@ -41,6 +43,10 @@ const coverageTreeNodeValuesSchema = z.object({
     .optional()
     .describe('Uncovered lines of code'),
 });
+export type CoverageTreeNodeValues = z.infer<
+  typeof coverageTreeNodeValuesSchema
+>;
+
 const coverageTreeNodeDataSchema = z.object({
   name: z.string().min(1).describe('File or folder name'),
   values: coverageTreeNodeValuesSchema.describe(

packages/utils/src/lib/coverage-tree.ts

@@ -1,11 +1,18 @@
 import type {
   CoverageTree,
   CoverageTreeMissingLOC,
-  CoverageTreeNode,
+  CoverageTreeNodeValues,
 } from '@code-pushup/models';
 import { splitFilePath } from './file-system.js';
 import { formatGitPath } from './git/git.js';
 
+// recursive schemas cause compiler problems when using CoverageTreeNode
+type TreeNode = {
+  name: string;
+  values: CoverageTreeNodeValues;
+  children?: TreeNode[];
+};
+
 export type FileCoverage = {
   path: string;
   total: number;
@@ -94,7 +101,7 @@ function addNode(
   };
 }
 
-function calculateTreeCoverage(root: FileTree): CoverageTreeNode {
+function calculateTreeCoverage(root: FileTree): TreeNode {
   if ('children' in root) {
     const stats = aggregateChildCoverage(root.children);
     const coverage = calculateCoverage(stats);
@@ -153,7 +160,7 @@ function getNodeCoverageStats(
   return stats;
 }
 
-function sortCoverageTree(root: CoverageTreeNode): CoverageTreeNode {
+function sortCoverageTree(root: TreeNode): TreeNode {
   if (!root.children?.length) {
     return root;
   }

packages/utils/src/lib/text-formats/ascii/tree.ts

@@ -1,16 +1,23 @@
 import type {
-  BasicTreeNode,
-  CoverageTreeNode,
+  BasicTreeNodeValues,
+  CoverageTreeNodeValues,
   Tree,
 } from '@code-pushup/models';
 
-type TreeNode = BasicTreeNode | CoverageTreeNode;
+// recursive schemas cause compiler problems when using BasicTreeNode | CoverageTreeNode
+type TreeNode = {
+  name: string;
+  values?: BasicTreeNodeValues | CoverageTreeNodeValues;
+  children?: TreeNode[];
+};
 
 const INDENT_CHARS = 4;
 const COL_GAP = 2;
 
 export function formatAsciiTree(tree: Tree): string {
-  const nodes = flatten(tree.root);
+  const root = tree.root as TreeNode;
+
+  const nodes = flatten(root);
   const maxWidth = Math.max(
     ...nodes.map(({ node, level }) => level * INDENT_CHARS + node.name.length),
   );
@@ -30,7 +37,7 @@ export function formatAsciiTree(tree: Tree): string {
           {},
         );
 
-  return formatTreeNode(tree.root, '', maxWidth, keysMaxWidths)
+  return formatTreeNode(root, '', maxWidth, keysMaxWidths)
     .map(line => `${line}\n`)
     .join('');
 }