Resolve dependencies from nested subgraphs (#147)

This PR introduces a small fix to the SubgraphResolver - subgraphs are resolved recursively.
Until now we only resolved one level of subgraphs, meaning not all graphs were taken into account when resolving dependencies.

packages/eslint-plugin-obsidian/rules/ast/utils.ts

@@ -1,5 +1,6 @@
 import type { TSESTree } from '@typescript-eslint/types';
 import type { ArrayExpressionElement } from '../unresolvedProviderDependencies/types';
+import { assertDefined } from '../utils/assertions';
 
 export function isClassLike(node: TSESTree.Node): node is TSESTree.ClassDeclaration {
   switch (node.type) {
@@ -35,12 +36,13 @@ export function getClassDeclaration(node: TSESTree.Node): TSESTree.ClassDeclarat
   }
 }
 
-export function requireProgram(node: TSESTree.Node): TSESTree.Program {
+export function requireProgram(node: TSESTree.Node | undefined): TSESTree.Program {
+  assertDefined(node);
   switch (node.type) {
     case 'Program':
       return node;
     default:
-      return requireProgram(node.parent!);
+      return requireProgram(node.parent);
   }
 }
 

packages/eslint-plugin-obsidian/rules/unresolvedProviderDependencies/dependencyResolver.ts

@@ -17,8 +17,7 @@ export class DependencyResolver {
   private getDependenciesFromSubgraphs(clazz: ClassWithImports): string[] {
     return this.subgraphResolver
       .resolve(clazz)
-      .map(this.getGraphDependencies)
-      .flat();
+      .flatMap(this.getGraphDependencies);
   }
 
   private getGraphDependencies({ clazz }: ClassWithImports) {

packages/eslint-plugin-obsidian/rules/unresolvedProviderDependencies/subgraphResolver.ts

@@ -10,10 +10,11 @@ import type { FileReader } from '../framework/fileReader';
 export class SubgraphResolver {
   constructor(private fileReader: FileReader) { }
 
-  public resolve(clazz: ClassWithImports) {
-    const importedGraphs = this.getImportedGraphs(clazz);
-    const localGraphs = this.getLocalGraphs(clazz);
-    return [...importedGraphs, ...localGraphs];
+  public resolve(clazz: ClassWithImports): ClassWithImports[] {
+    return [
+      ...this.getImportedGraphs(clazz),
+      ...this.getLocalGraphs(clazz),
+    ].flatMap((g) => [g, ...this.resolve(g)]);
   }
 
   private getImportedGraphs({ clazz, imports }: ClassWithImports) {
@@ -23,7 +24,7 @@ export class SubgraphResolver {
 
   private getImportedSubgraphClasses(subgraphs: Property | undefined, imports: Import[]) {
     if (!subgraphs) return [];
-    const subgraphNames = this.getSubgraphNames(subgraphs);
+    const subgraphNames = this.getSubgraphNamesFromDecoratorProperty(subgraphs);
     const classes: ClassWithImports[] = [];
     imports.forEach(($import) => {
       // TODO: convert this to a map with an inner for each?
@@ -48,16 +49,20 @@ export class SubgraphResolver {
 
   private getLocalSubgraphClasses(subgraphs: Property | undefined, { clazz, imports }: ClassWithImports) {
     if (!subgraphs) return [];
-    const subgraphNames = this.getSubgraphNames(subgraphs);
-    const localGraphNames = this.getLocalGraphNames(subgraphNames, imports);
+    const allSubgraphs = this.getSubgraphNamesFromDecoratorProperty(subgraphs);
+    const localGraphNames = this.getLocalGraphNames(allSubgraphs, imports);
+    return this.createLocalGraphClasses(clazz, localGraphNames, imports);
+  }
 
+  private createLocalGraphClasses(clazz: Clazz, localGraphNames: string[], imports: Import[]) {
+    if (localGraphNames.length === 0) return [];
     const parent = new File(requireProgram(clazz.node));
     return localGraphNames.map((localGraphName) => {
       return new ClassWithImports(parent.requireGraph(localGraphName), imports);
     });
   }
 
-  private getSubgraphNames(subgraphs: Property) {
+  private getSubgraphNamesFromDecoratorProperty(subgraphs: Property) {
     return mapArrayExpression(
       subgraphs.getValue<TSESTree.ArrayExpression>(),
       (el) => (el as TSESTree.Identifier).name,

packages/eslint-plugin-obsidian/tests/unresolvedProviderDependencies/fixtures/graphWithSubgraph.ts

@@ -0,0 +1,10 @@
+import { Graph, ObjectGraph, Provides } from 'react-obsidian';
+import Subgraph from './subgraph';
+
+@Graph({subgraphs: [Subgraph]})
+export default class GraphWithSubgraph extends ObjectGraph {
+  @Provides()
+  someString(instanceId: string, foo: string): string {
+    return `foo${instanceId}${foo}`;
+  }
+}

packages/eslint-plugin-obsidian/tests/unresolvedProviderDependencies/fixtures/subgraph.ts

@@ -12,4 +12,9 @@ export default class Subgraph extends ObjectGraph {
   instanceId(): string {
     return uniqueId('graph');
   }
+
+  @Provides()
+  foo(): string {
+    return 'foo';
+  }
 }

packages/eslint-plugin-obsidian/tests/unresolvedProviderDependencies/fixtures/validGraphs.ts

@@ -57,6 +57,22 @@ export default class SimpleGraphWithSubgraph extends ObjectGraph {
   }
 }`;
 
+export const validGraphWithNestedSubgraphs = `
+import {
+  Graph,
+  ObjectGraph,
+  Provides,
+}  from 'src';
+import GraphWithSubgraph from './graphWithSubgraph';
+
+@Graph({ subgraphs: [GraphWithSubgraph] })
+export default class GraphWithNestedSubgraphs extends ObjectGraph {
+  @Provides()
+  bar(foo: string): string {
+    return foo + 'bar';
+  }
+}`;
+
 export const validFileWithTwoGraphs = `
 import {
   Graph,

packages/eslint-plugin-obsidian/tests/unresolvedProviderDependencies/unresolvedDependencies.test.ts

@@ -5,6 +5,7 @@ import {
   validFileWithTwoGraphs,
   validGraph,
   validGraphWithNamedExportSubgraph,
+  validGraphWithNestedSubgraphs,
   validGraphWithRegularMethod,
   validGraphWithSubgraph,
   validLifecycleBoundGraphWithSubgraph,
@@ -24,6 +25,7 @@ ruleTester.run(
       validFileWithTwoGraphs,
       validGraphWithNamedExportSubgraph,
       validGraphWithRegularMethod,
+      validGraphWithNestedSubgraphs,
     ],
     invalid: [
       {