graphql-buddy 0.1.0 → 0.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "graphql-buddy",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "type": "module",
   "license": "MIT",
   "author": "Hunter John Larco",

package/src/api/commands/validate.test.ts

@@ -79,6 +79,12 @@ describe(`validate`, () => {
       ).resolves.toStrictEqual(expect.any(String));
     });
 
+    it(`throws for operations when the schema has no matching root type.`, async () => {
+      await expect(
+        validate.validate(documentsFixture(`missing_root_type`)),
+      ).rejects.toThrowError(`Schema does not define a query root type.`);
+    });
+
     it(`still validates field selections inside fragment-only files.`, async () => {
       await expect(
         validate.validate(documentsFixture(`invalid_fragment`)),

package/src/api/shared/validateDocuments.ts

@@ -22,24 +22,76 @@ export const validateDocuments = (options: ValidateDocumentsOptions): void => {
       continue;
     }
 
-    // Fragment-only documents are fragment "libraries" that operations pull in
-    // via `#import`. Validated in isolation they would trip
-    // `NoUnusedFragmentsRule`, so we drop that single rule for them. Every
-    // other rule, most importantly that each referenced field, argument, and
-    // type actually exists, are still enforced.
-    const definesOperation = source.document.definitions.some(
-      (definition) => definition.kind === graphql.Kind.OPERATION_DEFINITION,
-    );
-
-    const errors = graphql.validate(
-      schema,
-      source.document,
-      graphql.specifiedRules.filter(
-        (rule) => definesOperation || rule !== graphql.NoUnusedFragmentsRule,
-      ),
-    );
+    const errors = validateDocument(schema, source.document);
     if (errors.length > 0) {
       throw errors[0];
     }
   }
 };
+
+/**
+ * Validates a single document against the schema.
+ *
+ * This deliberately does not use `graphql.validate`. That function begins by
+ * asserting the *schema* is valid, which among other things requires a query
+ * root type. Fragment libraries are frequently validated against only the
+ * type definitions they select from.
+ *
+ * @param schema - The parsed graphql schema.
+ * @param document - The document to validate.
+ *
+ * @returns Any errors found in the document.
+ */
+const validateDocument = (
+  schema: graphql.GraphQLSchema,
+  document: graphql.DocumentNode,
+): Array<graphql.GraphQLError> => {
+  const errors: Array<graphql.GraphQLError> = [];
+
+  const operations = document.definitions.filter(
+    (definition): definition is graphql.OperationDefinitionNode =>
+      definition.kind === graphql.Kind.OPERATION_DEFINITION,
+  );
+
+  // Ensure each operation matches a root GraphQL type. This is not natively
+  // checked by the `ValidationContext` because the validation context only
+  // inspects operations whose type information is available.
+  for (const operation of operations) {
+    if (schema.getRootType(operation.operation) == null) {
+      errors.push(
+        new graphql.GraphQLError(
+          `Schema does not define a ${operation.operation} root type.`,
+          { nodes: operation },
+        ),
+      );
+    }
+  }
+
+  // Fragment-only documents are fragment "libraries" that operations pull in
+  // via `#import`. Validated in isolation they would trip
+  // `NoUnusedFragmentsRule`, so we drop that single rule for them. Every
+  // other rule, most importantly that each referenced field, argument, and
+  // type actually exists, are still enforced.
+  const rules = graphql.specifiedRules.filter(
+    (rule) => operations.length > 0 || rule !== graphql.NoUnusedFragmentsRule,
+  );
+
+  const typeInfo = new graphql.TypeInfo(schema);
+  const context = new graphql.ValidationContext(
+    schema,
+    document,
+    typeInfo,
+    (error) => {
+      errors.push(error);
+    },
+  );
+  graphql.visit(
+    document,
+    graphql.visitWithTypeInfo(
+      typeInfo,
+      graphql.visitInParallel(rules.map((rule) => rule(context))),
+    ),
+  );
+
+  return errors;
+};

package/test_fixtures/documents/fragment_library/schema/Foo.graphql

@@ -0,0 +1,7 @@
+type Foo {
+  id: ID!
+  name: String
+  dateCreated: DateTime!
+}
+
+scalar DateTime

package/test_fixtures/documents/missing_root_type/documents/AllFoo.graphql

@@ -0,0 +1,5 @@
+query AllFoo {
+  allFoo {
+    id
+  }
+}

package/test_fixtures/documents/missing_root_type/schema/Foo.graphql

@@ -0,0 +1,7 @@
+type Foo {
+  id: ID!
+  name: String
+  dateCreated: DateTime!
+}
+
+scalar DateTime

package/test_fixtures/documents/fragment_library/schema/schema.graphql

@@ -1,20 +0,0 @@
-type Query {
-  allFoo: [Foo!]!
-  foo(id: ID!): Foo
-}
-
-type Foo {
-  id: ID!
-  name: String
-  bar: Bar
-}
-
-type Bar {
-  baz: Baz
-}
-
-type Baz {
-  dateCreated: DateTime!
-}
-
-scalar DateTime