added logic to sort GraphQL schemas based on dependencies

Author: Code-Hex

package.json

@@ -50,6 +50,7 @@
     "@graphql-codegen/cli": "4.0.1",
     "@graphql-codegen/typescript": "^4.0.0",
     "@tsconfig/recommended": "1.0.2",
+    "@types/graphlib": "^2.1.8",
     "@types/jest": "29.5.2",
     "@types/node": "^20.1.3",
     "@typescript-eslint/eslint-plugin": "5.59.8",
@@ -59,6 +60,7 @@
     "myzod": "1.10.0",
     "npm-run-all": "4.1.5",
     "prettier": "2.8.8",
+    "ts-dedent": "^2.2.0",
     "ts-jest": "29.1.0",
     "typescript": "5.1.3",
     "yup": "1.2.0",
@@ -69,6 +71,7 @@
     "@graphql-codegen/schema-ast": "4.0.0",
     "@graphql-codegen/visitor-plugin-common": "^4.0.0",
     "@graphql-tools/utils": "^10.0.0",
+    "graphlib": "^2.1.8",
     "graphql": "^16.6.0"
   },
   "peerDependencies": {

src/graphql.ts

@@ -1,4 +1,17 @@
-import { ListTypeNode, NonNullTypeNode, NamedTypeNode, TypeNode, ObjectTypeDefinitionNode } from 'graphql';
+import {
+  ListTypeNode,
+  NonNullTypeNode,
+  NamedTypeNode,
+  TypeNode,
+  ObjectTypeDefinitionNode,
+  visit,
+  DocumentNode,
+  DefinitionNode,
+  NameNode,
+  ASTNode,
+  GraphQLSchema,
+} from 'graphql';
+import { Graph } from 'graphlib';
 
 export const isListType = (typ?: TypeNode): typ is ListTypeNode => typ?.kind === 'ListType';
 export const isNonNullType = (typ?: TypeNode): typ is NonNullTypeNode => typ?.kind === 'NonNullType';
@@ -20,3 +33,134 @@ export const ObjectTypeDefinitionBuilder = (
     return callback(node);
   };
 };
+
+export const topologicalSortAST = (schema: GraphQLSchema, ast: DocumentNode): DocumentNode => {
+  const dependencyGraph = new Graph();
+  const targetKinds = [
+    'ObjectTypeDefinition',
+    'InputObjectTypeDefinition',
+    'EnumTypeDefinition',
+    'UnionTypeDefinition',
+    'ScalarTypeDefinition',
+  ];
+
+  visit<DocumentNode>(ast, {
+    enter: node => {
+      switch (node.kind) {
+        case 'ObjectTypeDefinition':
+        case 'InputObjectTypeDefinition': {
+          const typeName = node.name.value;
+          dependencyGraph.setNode(typeName);
+
+          if (node.fields) {
+            node.fields.forEach(field => {
+              if (field.type.kind === 'NamedType') {
+                const dependency = field.type.name.value;
+                const typ = schema.getType(dependency);
+                if (typ?.astNode?.kind === undefined || !targetKinds.includes(typ.astNode.kind)) {
+                  return;
+                }
+                if (!dependencyGraph.hasNode(dependency)) {
+                  dependencyGraph.setNode(dependency);
+                }
+                dependencyGraph.setEdge(typeName, dependency);
+              }
+            });
+          }
+          break;
+        }
+        case 'ScalarTypeDefinition':
+        case 'EnumTypeDefinition': {
+          dependencyGraph.setNode(node.name.value);
+          break;
+        }
+        case 'UnionTypeDefinition': {
+          const dependency = node.name.value;
+          if (!dependencyGraph.hasNode(dependency)) {
+            dependencyGraph.setNode(dependency);
+          }
+          node.types?.forEach(type => {
+            const dependency = type.name.value;
+            const typ = schema.getType(dependency);
+            if (typ?.astNode?.kind === undefined || !targetKinds.includes(typ.astNode.kind)) {
+              return;
+            }
+            dependencyGraph.setEdge(node.name.value, dependency);
+          });
+          break;
+        }
+        default:
+          break;
+      }
+    },
+  });
+
+  const sorted = topsort(dependencyGraph);
+
+  // Create a map of definitions for quick access, using the definition's name as the key.
+  const definitionsMap: Map<string, DefinitionNode> = new Map();
+  ast.definitions.forEach(definition => {
+    if (hasNameField(definition) && definition.name) {
+      definitionsMap.set(definition.name.value, definition);
+    }
+  });
+
+  // Two arrays to store sorted and not sorted definitions.
+  const sortedDefinitions: DefinitionNode[] = [];
+  const notSortedDefinitions: DefinitionNode[] = [];
+
+  // Iterate over sorted type names and retrieve their corresponding definitions.
+  sorted.forEach(sortedType => {
+    const definition = definitionsMap.get(sortedType);
+    if (definition) {
+      sortedDefinitions.push(definition);
+      definitionsMap.delete(sortedType);
+    }
+  });
+
+  // Definitions that are left in the map were not included in sorted list
+  // Add them to notSortedDefinitions.
+  definitionsMap.forEach(definition => notSortedDefinitions.push(definition));
+
+  const definitions = [...sortedDefinitions, ...notSortedDefinitions];
+
+  if (definitions.length !== ast.definitions.length) {
+    throw new Error(
+      `unexpected definition length after sorted: want ${ast.definitions.length} but got ${definitions.length}`
+    );
+  }
+
+  return {
+    ...ast,
+    definitions: definitions as ReadonlyArray<DefinitionNode>,
+  };
+};
+
+const hasNameField = (node: ASTNode): node is DefinitionNode & { name?: NameNode } => {
+  return 'name' in node;
+};
+
+// Re-implemented w/o CycleException version
+// https://github.com/dagrejs/graphlib/blob/8d27cb89029081c72eb89dde652602805bdd0a34/lib/alg/topsort.js
+export const topsort = (g: Graph): string[] => {
+  const visited: Record<string, boolean> = {};
+  const stack: Record<string, boolean> = {};
+  const results: any[] = [];
+
+  function visit(node: string) {
+    if (!(node in visited)) {
+      stack[node] = true;
+      visited[node] = true;
+      const predecessors = g.predecessors(node);
+      if (Array.isArray(predecessors)) {
+        predecessors.forEach(node => visit(node));
+      }
+      delete stack[node];
+      results.push(node);
+    }
+  }
+
+  g.sinks().forEach(node => visit(node));
+
+  return results.reverse();
+};

src/index.ts

@@ -6,13 +6,14 @@ import { ValidationSchemaPluginConfig } from './config';
 import { PluginFunction, Types } from '@graphql-codegen/plugin-helpers';
 import { GraphQLSchema, visit } from 'graphql';
 import { SchemaVisitor } from './types';
+import { topologicalSortAST } from './graphql';
 
 export const plugin: PluginFunction<ValidationSchemaPluginConfig, Types.ComplexPluginOutput> = (
   schema: GraphQLSchema,
   _documents: Types.DocumentFile[],
   config: ValidationSchemaPluginConfig
 ): Types.ComplexPluginOutput => {
-  const { schema: _schema, ast } = transformSchemaAST(schema, config);
+  const { schema: _schema, ast } = _transformSchemaAST(schema, config);
   const { buildImports, initialEmit, ...visitor } = schemaVisitor(_schema, config);
 
   const result = visit(ast, visitor);
@@ -35,3 +36,17 @@ const schemaVisitor = (schema: GraphQLSchema, config: ValidationSchemaPluginConf
   }
   return YupSchemaVisitor(schema, config);
 };
+
+const _transformSchemaAST = (schema: GraphQLSchema, config: ValidationSchemaPluginConfig) => {
+  const { schema: _schema, ast } = transformSchemaAST(schema, config);
+  if (config.validationSchemaExportType === 'const') {
+    return {
+      schema: _schema,
+      ast: topologicalSortAST(_schema, ast),
+    };
+  }
+  return {
+    schema: _schema,
+    ast,
+  };
+};