remove old files, rename new files in their place

Author: lopert

src/methods/validate-fixture-input.ts

@@ -1,81 +1,111 @@
-import { graphql, GraphQLSchema } from 'graphql';
-import { convertFixtureToQuery } from '../utils/convert-fixture-to-query.js';
+import { visit, DocumentNode, Kind } from "graphql";
+import { TypeInfo, visitWithTypeInfo, coerceInputValue } from "graphql";
+import {
+  isInputType,
+  isListType,
+  isNullableType,
+  GraphQLSchema,
+  getNullableType,
+  isAbstractType,
+  getNamedType,
+} from "graphql";
+import { inlineNamedFragmentSpreads } from "../utils/inline-named-fragment-spreads.js";
 
-/**
- * Interface for validation result
- */
-export interface ValidationResult {
+export interface ValidateFixtureInputResult {
   valid: boolean;
   errors: string[];
-  data: any;
-  query: string | null;
 }
 
-/**
- * Validate input fixture data using the original schema with Query root
- * 
- * Since input fixture data represents the result of running an input query 
- * against the schema, we can validate it by generating a query from the fixture
- * structure and executing it against the original schema directly.
- * 
- * This approach is simpler than building reduced schemas because:
- * 1. The original schema already has a Query root type
- * 2. No need to convert input types to output types  
- * 3. Uses the full schema context for validation
- * 4. Leverages existing resolvers if any
- * 
- * @param {Object} inputFixtureData - The input fixture data to validate
- * @param {GraphQLSchema} originalSchema - The original GraphQL schema with Query root
- * @returns {Promise<Object>} Validation result with structure:
- *   - valid: boolean - Whether the fixture data is valid
- *   - errors: string[] - Array of error messages (empty if valid)
- *   - data: Object|null - The resulting data from query execution
- *   - query: string|null - The GraphQL query generated from fixture structure
- */
+export function validateFixtureInput(
+  queryAST: DocumentNode,
+  schema: GraphQLSchema,
+  value: any
+): ValidateFixtureInputResult {
+  const inlineFragmentSpreadsAst = inlineNamedFragmentSpreads(queryAST);
+  const typeInfo = new TypeInfo(schema);
+  const valueStack: any[] = [[value]];
+  const errors: string[] = [];
+  visit(
+    inlineFragmentSpreadsAst,
+    visitWithTypeInfo(typeInfo, {
+      Field: {
+        enter(node) {
+          const currentValues = valueStack[valueStack.length - 1];
+          const nestedValues = [];
 
-export async function validateFixtureInput(
-  inputFixtureData: Record<string, any>,
-  originalSchema: GraphQLSchema
-): Promise<ValidationResult> {
-  try {
-    // Step 1: Convert fixture data structure to a GraphQL query
-    // The query directly matches the Input type structure (no field wrapper needed)
-    const query = convertFixtureToQuery(inputFixtureData, '');
-    
-    // Step 2: Execute the query against the original schema
-    // The fixture data becomes the root value that resolvers will traverse
-    const result = await graphql({
-      schema: originalSchema,
-      source: query,
-      rootValue: inputFixtureData
-    });
+          const responseKey = node.alias?.value || node.name.value;
 
-    if (result.errors && result.errors.length > 0) {
-      return {
-        valid: false,
-        errors: result.errors.map(err => err.message),
-        data: result.data || null,
-        query
-      };
-    }
+          const fieldDefinition = typeInfo.getFieldDef();
+          const fieldType = fieldDefinition?.type;
 
-    // If we successfully executed the query and got data back,
-    // it means the fixture structure matches what the schema expects
-    return {
-      valid: true,
-      errors: [],
-      data: result.data,
-      query
-    };
+          for (const currentValue of currentValues) {
+            const valueForResponseKey = currentValue[responseKey];
 
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    return {
-      valid: false,
-      errors: [`Input fixture validation failed: ${errorMessage}`],
-      data: null,
-      query: null
-    };
-  }
-}
+            if (valueForResponseKey === undefined) {
+              errors.push(`Missing expected fixture data for ${responseKey}`);
+              continue;
+            } else if (isInputType(fieldType)) {
+              coerceInputValue(
+                valueForResponseKey,
+                fieldType,
+                (path, _invalidValue, error) => {
+                  errors.push(`${error.message} At "${path.join(".")}"`);
+                }
+              );
+            } else if (
+              isNullableType(fieldType) &&
+              valueForResponseKey === null
+            ) {
+              continue;
+            } else if (isListType(getNullableType(fieldType))) {
+              if (Array.isArray(valueForResponseKey)) {
+                nestedValues.push(...valueForResponseKey);
+              } else {
+                errors.push(
+                  `Expected array for ${responseKey}, but got ${typeof valueForResponseKey}`
+                );
+              }
+            } else {
+              if (typeof valueForResponseKey === "object") {
+                nestedValues.push(valueForResponseKey);
+              } else {
+                errors.push(
+                  `Expected object for ${responseKey}, but got ${typeof valueForResponseKey}`
+                );
+              }
+            }
+          }
+
+          valueStack.push(nestedValues);
+        },
+        leave() {
+          valueStack.pop();
+        },
+      },
+      SelectionSet: {
+        enter(node) {
+          if (isAbstractType(getNamedType(typeInfo.getType()))) {
+            const hasTypename = node.selections.some(
+              (selection) =>
+                selection.kind == Kind.FIELD &&
+                selection.name.value == "__typename"
+            );
 
+            const fragmentSpreadCount = node.selections.filter(
+              (selection) =>
+                selection.kind == Kind.FRAGMENT_SPREAD ||
+                selection.kind == Kind.INLINE_FRAGMENT
+            ).length;
+
+            if (!hasTypename && fragmentSpreadCount > 1) {
+              errors.push(
+                `Missing __typename field for abstract type ${getNamedType(typeInfo.getType())?.name}`
+              );
+            }
+          }
+        },
+      },
+    })
+  );
+  return { valid: errors.length === 0, errors };
+}