ardatan · ardatan · May 13, 2025 · May 13, 2025 · May 13, 2025 · May 13, 2025
diff --git a/.changeset/tame-lizards-fly.md b/.changeset/tame-lizards-fly.md
@@ -0,0 +1,5 @@
+---
+'@graphql-tools/utils': minor
+---
+
+Introduce fast type checkers that avoid `instanceOf`
diff --git a/.changeset/tidy-nails-lick.md b/.changeset/tidy-nails-lick.md
@@ -0,0 +1,9 @@
+---
+'@graphql-tools/executor': patch
+'@graphql-tools/schema': patch
+'@graphql-tools/utils': patch
+'@graphql-tools/load': patch
+'@graphql-tools/mock': patch
+---
+
+Use faster type checkers, and avoid `instanceOf`
diff --git a/packages/executor/src/execution/execute.ts b/packages/executor/src/execution/execute.ts
@@ -15,17 +15,13 @@ import {
   GraphQLOutputType,
   GraphQLSchema,
   GraphQLTypeResolver,
-  isAbstractType,
-  isLeafType,
-  isListType,
-  isNonNullType,
-  isObjectType,
   Kind,
   locatedError,
   OperationDefinitionNode,
   SchemaMetaFieldDef,
   TypeMetaFieldDef,
   TypeNameMetaFieldDef,
+  validateSchema,
   versionInfo,
 } from 'graphql';
 import {
@@ -39,9 +35,14 @@ import {
   GraphQLResolveInfo,
   GraphQLStreamDirective,
   inspect,
+  isAbstractType,
   isAsyncIterable,
   isIterableObject,
+  isLeafType,
+  isListType,
+  isNonNullType,
   isObjectLike,
+  isObjectType,
   isPromise,
   mapAsyncIterator,
   Maybe,
@@ -396,6 +397,8 @@ export const getFragmentsFromDocument = memoize1(function getFragmentsFromDocume
   return fragments;
 });
 
+const validSchemas = new WeakSet<GraphQLSchema>();
+
 /**
  * Constructs a ExecutionContext object from the arguments passed to
  * execute, which we will pass throughout the other execution methods.
@@ -424,7 +427,13 @@ export function buildExecutionContext<TData = any, TVariables = any, TContext =
   signal?.throwIfAborted();
 
   // If the schema used for execution is invalid, throw an error.
-  assertValidSchema(schema);
+  if (!validSchemas.has(schema)) {
+    const validationErrors = validateSchema(schema);
+    if (validationErrors?.length) {
+      return validationErrors;
+    }
+    validSchemas.add(schema);
+  }
 
   const fragments: Record<string, FragmentDefinitionNode> = getFragmentsFromDocument(document);
 

diff --git a/packages/executor/src/execution/values.ts b/packages/executor/src/execution/values.ts
@@ -2,15 +2,20 @@ import {
   coerceInputValue,
   GraphQLError,
   GraphQLSchema,
-  isInputType,
-  isNonNullType,
   NamedTypeNode,
   print,
   typeFromAST,
   valueFromAST,
   VariableDefinitionNode,
 } from 'graphql';
-import { createGraphQLError, hasOwnProperty, inspect, printPathArray } from '@graphql-tools/utils';
+import {
+  createGraphQLError,
+  hasOwnProperty,
+  inspect,
+  isInputType,
+  isNonNullType,
+  printPathArray,
+} from '@graphql-tools/utils';
 
 type CoercedVariableValues =
   | { errors: ReadonlyArray<GraphQLError>; coerced?: never }

diff --git a/packages/load/src/load-typedefs/collect-sources.ts b/packages/load/src/load-typedefs/collect-sources.ts
@@ -1,12 +1,13 @@
 import { createRequire } from 'module';
 import { cwd } from 'process';
-import { isSchema, Kind } from 'graphql';
+import { Kind } from 'graphql';
 import {
   asArray,
   debugTimerEnd,
   debugTimerStart,
   getDocumentNodeFromSchema,
   isDocumentString,
+  isSchema,
   parseGraphQLSDL,
   Source,
 } from '@graphql-tools/utils';

diff --git a/packages/load/tests/loaders/schema/schema-from-export.spec.ts b/packages/load/tests/loaders/schema/schema-from-export.spec.ts
@@ -1,4 +1,4 @@
-import { isSchema } from 'graphql';
+import { GraphQLSchema } from 'graphql';
 import { CodeFileLoader } from '@graphql-tools/code-file-loader';
 import { loadSchema, loadSchemaSync } from '@graphql-tools/load';
 import { runTests, useMonorepo } from '../../../../testing/utils.js';
@@ -28,7 +28,7 @@ describe('Schema From Export', () => {
           cwd: __dirname,
         },
       );
-      expect(isSchema(result)).toBeTruthy();
+      expect(result).toBeInstanceOf(GraphQLSchema);
     });
 
     it('should load the schema (with extend) correctly from module.exports', async () => {
@@ -39,7 +39,7 @@ describe('Schema From Export', () => {
           cwd: __dirname,
         },
       );
-      expect(isSchema(result)).toBeTruthy();
+      expect(result).toBeInstanceOf(GraphQLSchema);
       const QueryType = result.getQueryType();
       assertNonMaybe(QueryType);
       expect(QueryType.getFields()['hello']).toBeDefined();
@@ -53,7 +53,7 @@ describe('Schema From Export', () => {
           cwd: __dirname,
         },
       );
-      expect(isSchema(result)).toBeTruthy();
+      expect(result).toBeInstanceOf(GraphQLSchema);
     });
 
     it('should load the schema correctly from default export', async () => {
@@ -64,7 +64,7 @@ describe('Schema From Export', () => {
           cwd: __dirname,
         },
       );
-      expect(isSchema(result)).toBeTruthy();
+      expect(result).toBeInstanceOf(GraphQLSchema);
     });
 
     if (mode === 'async') {
@@ -76,7 +76,7 @@ describe('Schema From Export', () => {
             cwd: __dirname,
           },
         );
-        expect(isSchema(result)).toBeTruthy();
+        expect(result).toBeInstanceOf(GraphQLSchema);
       });
 
       it('should load the schema correctly from promise export', async () => {
@@ -87,7 +87,7 @@ describe('Schema From Export', () => {
             cwd: __dirname,
           },
         );
-        expect(isSchema(result)).toBeTruthy();
+        expect(result).toBeInstanceOf(GraphQLSchema);
       });
     }
 

diff --git a/packages/load/tests/loaders/schema/schema-from-json.spec.ts b/packages/load/tests/loaders/schema/schema-from-json.spec.ts
@@ -1,8 +1,9 @@
 import { readFileSync } from 'fs';
 import { join } from 'path';
-import { isSchema, isSpecifiedScalarType } from 'graphql';
+import { GraphQLSchema } from 'graphql';
 import { JsonFileLoader } from '@graphql-tools/json-file-loader';
 import { loadSchema, loadSchemaSync } from '@graphql-tools/load';
+import { isSpecifiedScalarType } from '@graphql-tools/utils';
 import { runTests, useMonorepo } from '../../../../testing/utils.js';
 
 const monorepo = useMonorepo({
@@ -27,14 +28,14 @@ describe('Schema From Export', () => {
         loaders: [new JsonFileLoader()],
         cwd: __dirname,
       });
-      expect(isSchema(schema)).toBeTruthy();
+      expect(schema).toBeInstanceOf(GraphQLSchema);
     });
     it('should load the schema with correct descriptions', async () => {
       const schema = await load('./test-files/githunt.json', {
         loaders: [new JsonFileLoader()],
         cwd: __dirname,
       });
-      expect(isSchema(schema)).toBeTruthy();
+      expect(schema).toBeInstanceOf(GraphQLSchema);
       for (const typeName in schema.getTypeMap()) {
         const githuntJsonFile = readFileSync(join(__dirname, './test-files/githunt.json'), 'utf-8');
         const introspectionSchema = JSON.parse(githuntJsonFile).__schema;

diff --git a/packages/merge/src/typedefs-mergers/utils.ts b/packages/merge/src/typedefs-mergers/utils.ts
@@ -5,7 +5,7 @@ export function isStringTypes(types: any): types is string {
 }
 
 export function isSourceTypes(types: any): types is Source {
-  return types instanceof Source;
+  return types?.[Symbol.toStringTag] === 'Source';
 }
 
 export function extractType(type: TypeNode): NamedTypeNode {

diff --git a/packages/mock/src/MockStore.ts b/packages/mock/src/MockStore.ts
@@ -1,9 +1,7 @@
 import stringify from 'fast-json-stable-stringify';
+import { GraphQLOutputType, GraphQLSchema, GraphQLString } from 'graphql';
 import {
   getNullableType,
-  GraphQLOutputType,
-  GraphQLSchema,
-  GraphQLString,
   isAbstractType,
   isCompositeType,
   isEnumType,
@@ -12,7 +10,7 @@ import {
   isNullableType,
   isObjectType,
   isScalarType,
-} from 'graphql';
+} from '@graphql-tools/utils';
 import { deepResolveMockList, isMockList } from './MockList.js';
 import {
   assertIsRef,

diff --git a/packages/mock/src/addMocksToSchema.ts b/packages/mock/src/addMocksToSchema.ts
@@ -6,10 +6,9 @@ import {
   GraphQLTypeResolver,
   GraphQLUnionType,
   isSchema,
-  isUnionType,
 } from 'graphql';
 import { addResolversToSchema } from '@graphql-tools/schema';
-import { IResolvers, MapperKind, mapSchema } from '@graphql-tools/utils';
+import { IResolvers, isUnionType, MapperKind, mapSchema } from '@graphql-tools/utils';
 import { createMockStore } from './MockStore.js';
 import { IMocks, IMockStore, isRef, TypePolicy } from './types.js';
 import { copyOwnProps, isObject, isRootType } from './utils.js';

diff --git a/packages/schema/src/addResolversToSchema.ts b/packages/schema/src/addResolversToSchema.ts
@@ -8,19 +8,19 @@ import {
   GraphQLScalarType,
   GraphQLSchema,
   GraphQLUnionType,
-  isEnumType,
-  isInterfaceType,
-  isObjectType,
-  isScalarType,
-  isSpecifiedScalarType,
-  isUnionType,
 } from 'graphql';
 import {
   forEachDefaultValue,
   forEachField,
   healSchema,
   IAddResolversToSchemaOptions,
   IResolvers,
+  isEnumType,
+  isInterfaceType,
+  isObjectType,
+  isScalarType,
+  isSpecifiedScalarType,
+  isUnionType,
   MapperKind,
   mapSchema,
   parseInputValue,

diff --git a/packages/schema/src/assertResolversPresent.ts b/packages/schema/src/assertResolversPresent.ts
@@ -1,5 +1,11 @@
-import { getNamedType, GraphQLField, GraphQLSchema, isScalarType } from 'graphql';
-import { forEachField, IResolverValidationOptions, ValidatorBehavior } from '@graphql-tools/utils';
+import { GraphQLField, GraphQLSchema } from 'graphql';
+import {
+  forEachField,
+  getNamedType,
+  IResolverValidationOptions,
+  isScalarType,
+  ValidatorBehavior,
+} from '@graphql-tools/utils';
 
 export function assertResolversPresent(
   schema: GraphQLSchema,

diff --git a/packages/utils/src/addTypes.ts b/packages/utils/src/addTypes.ts
@@ -26,15 +26,10 @@
 // enhanceSchema can fill this gap by adding an additional round of rewiring.
 //
 
-import {
-  GraphQLDirective,
-  GraphQLNamedType,
-  GraphQLSchema,
-  isDirective,
-  isNamedType,
-} from 'graphql';
+import { GraphQLDirective, GraphQLNamedType, GraphQLSchema, isDirective } from 'graphql';
 import { getObjectTypeFromTypeMap } from './getObjectTypeFromTypeMap.js';
 import { rewireTypes } from './rewire.js';
+import { isNamedType } from './typeCheckers.js';
 
 export function addTypes(
   schema: GraphQLSchema,

diff --git a/packages/utils/src/astFromType.ts b/packages/utils/src/astFromType.ts
@@ -1,5 +1,6 @@
 import { inspect } from 'cross-inspect';
-import { GraphQLType, isListType, isNonNullType, Kind, TypeNode } from 'graphql';
+import { GraphQLType, Kind, TypeNode } from 'graphql';
+import { isListType, isNonNullType } from './typeCheckers.js';
 
 export function astFromType(type: GraphQLType): TypeNode {
   if (isNonNullType(type)) {

diff --git a/packages/utils/src/astFromValue.ts b/packages/utils/src/astFromValue.ts
@@ -1,17 +1,14 @@
 import { inspect } from 'cross-inspect';
+import { Kind, ObjectFieldNode, ValueNode, type GraphQLInputType } from 'graphql';
+import { astFromValueUntyped } from './astFromValueUntyped.js';
+import { isIterableObject, isObjectLike } from './jsutils.js';
 import {
-  GraphQLInputType,
   isEnumType,
   isInputObjectType,
   isLeafType,
   isListType,
   isNonNullType,
-  Kind,
-  ObjectFieldNode,
-  ValueNode,
-} from 'graphql';
-import { astFromValueUntyped } from './astFromValueUntyped.js';
-import { isIterableObject, isObjectLike } from './jsutils.js';
+} from './typeCheckers.js';
 import { Maybe } from './types.js';
 
 /**

diff --git a/packages/utils/src/build-operation-for-field.ts b/packages/utils/src/build-operation-for-field.ts
@@ -1,6 +1,5 @@
 import {
   ArgumentNode,
-  getNamedType,
   GraphQLArgument,
   GraphQLField,
   GraphQLInputType,
@@ -10,13 +9,6 @@ import {
   GraphQLObjectType,
   GraphQLSchema,
   InlineFragmentNode,
-  isEnumType,
-  isInterfaceType,
-  isListType,
-  isNonNullType,
-  isObjectType,
-  isScalarType,
-  isUnionType,
   Kind,
   ListTypeNode,
   NonNullTypeNode,
@@ -28,6 +20,16 @@ import {
   VariableDefinitionNode,
 } from 'graphql';
 import { getDefinedRootType, getRootTypeNames } from './rootTypes.js';
+import {
+  getNamedType,
+  isEnumType,
+  isInterfaceType,
+  isListType,
+  isNonNullType,
+  isObjectType,
+  isScalarType,
+  isUnionType,
+} from './typeCheckers.js';
 
 let operationVariables: VariableDefinitionNode[] = [];
 let fieldTypeMap = new Map();

diff --git a/packages/utils/src/collectFields.ts b/packages/utils/src/collectFields.ts
@@ -8,14 +8,14 @@ import {
   GraphQLSchema,
   GraphQLSkipDirective,
   InlineFragmentNode,
-  isAbstractType,
   Kind,
   SelectionSetNode,
   typeFromAST,
 } from 'graphql';
 import { AccumulatorMap } from './AccumulatorMap.js';
 import { GraphQLDeferDirective } from './directives.js';
 import { memoize5 } from './memoize.js';
+import { isAbstractType } from './typeCheckers.js';
 
 export interface PatchFields {
   label: string | undefined;

diff --git a/packages/utils/src/forEachDefaultValue.ts b/packages/utils/src/forEachDefaultValue.ts
@@ -1,12 +1,13 @@
-import { getNamedType, GraphQLSchema, isInputObjectType, isObjectType } from 'graphql';
+import { GraphQLSchema } from 'graphql';
 import { IDefaultValueIteratorFn } from './Interfaces.js';
+import { isInputObjectType, isIntrospectionType, isObjectType } from './typeCheckers.js';
 
 export function forEachDefaultValue(schema: GraphQLSchema, fn: IDefaultValueIteratorFn): void {
   const typeMap = schema.getTypeMap();
   for (const typeName in typeMap) {
     const type = typeMap[typeName];
 
-    if (!getNamedType(type).name.startsWith('__')) {
+    if (!isIntrospectionType(type)) {
       if (isObjectType(type)) {
         const fields = type.getFields();
         for (const fieldName in fields) {