@graphql-mesh/graphql 1.0.0-alpha-3fc47d119.0 → 1.0.0-alpha-20230420181317-a95037648

package/{index.js → cjs/index.js}

@@ -1,38 +1,46 @@
-'use strict';
-
-function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
-
-const urlLoader = require('@graphql-tools/url-loader');
-const graphql = require('graphql');
-const wrap = require('@graphql-tools/wrap');
-const utils = require('@graphql-mesh/utils');
-const utils$1 = require('@graphql-tools/utils');
-const store = require('@graphql-mesh/store');
-const lodashGet = _interopDefault(require('lodash.get'));
-const stringInterpolation = require('@graphql-mesh/string-interpolation');
-const crossHelpers = require('@graphql-mesh/cross-helpers');
-
-const getResolverData = utils$1.memoize1(function getResolverData(params) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const graphql_1 = require("graphql");
+const lodash_get_1 = tslib_1.__importDefault(require("lodash.get"));
+const cross_helpers_1 = require("@graphql-mesh/cross-helpers");
+const store_1 = require("@graphql-mesh/store");
+const string_interpolation_1 = require("@graphql-mesh/string-interpolation");
+const utils_1 = require("@graphql-mesh/utils");
+const url_loader_1 = require("@graphql-tools/url-loader");
+const utils_2 = require("@graphql-tools/utils");
+const wrap_1 = require("@graphql-tools/wrap");
+const getResolverData = (0, utils_2.memoize1)(function getResolverData(params) {
     return {
         root: params.rootValue,
         args: params.variables,
         context: params.context,
-        env: crossHelpers.process.env,
+        env: cross_helpers_1.process.env,
     };
 });
 class GraphQLHandler {
-    constructor({ config, baseDir, fetchFn, store: store$1, importFn, logger, }) {
-        this.urlLoader = new urlLoader.UrlLoader();
+    constructor({ name, config, baseDir, store, importFn, logger, }) {
+        this.urlLoader = new url_loader_1.UrlLoader();
         this.interpolationStringSet = new Set();
+        this.name = name;
         this.config = config;
         this.baseDir = baseDir;
-        this.fetchFn = fetchFn;
-        this.nonExecutableSchema = store$1.proxy('introspectionSchema', store.PredefinedProxyOptions.GraphQLSchemaWithDiffing);
+        this.nonExecutableSchema = store.proxy('introspectionSchema', store_1.PredefinedProxyOptions.GraphQLSchemaWithDiffing);
         this.importFn = importFn;
         this.logger = logger;
     }
     getArgsAndContextVariables() {
-        return stringInterpolation.parseInterpolationStrings(this.interpolationStringSet);
+        return (0, string_interpolation_1.parseInterpolationStrings)(this.interpolationStringSet);
+    }
+    wrapExecutorToPassSourceNameAndDebug(executor) {
+        const sourceName = this.name;
+        const logger = this.logger;
+        return function executorWithSourceName(executionRequest) {
+            logger.debug(() => `Sending GraphQL Request: `, (0, graphql_1.print)(executionRequest.document));
+            executionRequest.info = executionRequest.info || {};
+            executionRequest.info.sourceName = sourceName;
+            return executor(executionRequest);
+        };
     }
     async getExecutorForHTTPSourceConfig(httpSourceConfig) {
         const { endpoint, operationHeaders = {} } = httpSourceConfig;
@@ -40,8 +48,8 @@ class GraphQLHandler {
         Object.keys(operationHeaders).forEach(headerName => {
             this.interpolationStringSet.add(headerName.toString());
         });
-        const endpointFactory = stringInterpolation.getInterpolatedStringFactory(endpoint);
-        const operationHeadersFactory = stringInterpolation.getInterpolatedHeadersFactory(operationHeaders);
+        const endpointFactory = (0, string_interpolation_1.getInterpolatedStringFactory)(endpoint);
+        const operationHeadersFactory = (0, string_interpolation_1.getInterpolatedHeadersFactory)(operationHeaders);
         const executor = this.urlLoader.getExecutorAsync(endpoint, {
             ...httpSourceConfig,
             subscriptionsProtocol: httpSourceConfig.subscriptionsProtocol,
@@ -59,43 +67,63 @@ class GraphQLHandler {
             });
         };
     }
+    getSchemaFromContent(sdlOrIntrospection) {
+        if (typeof sdlOrIntrospection === 'string') {
+            return (0, graphql_1.buildSchema)(sdlOrIntrospection, {
+                assumeValid: true,
+                assumeValidSDL: true,
+            });
+        }
+        else if ((0, utils_2.isDocumentNode)(sdlOrIntrospection)) {
+            return (0, graphql_1.buildASTSchema)(sdlOrIntrospection, {
+                assumeValid: true,
+                assumeValidSDL: true,
+            });
+        }
+        else if (sdlOrIntrospection.__schema) {
+            return (0, graphql_1.buildClientSchema)(sdlOrIntrospection, {
+                assumeValid: true,
+            });
+        }
+        throw new Error(`Invalid introspection data: ${cross_helpers_1.util.inspect(sdlOrIntrospection)}`);
+    }
     async getNonExecutableSchemaForHTTPSource(httpSourceConfig) {
         this.interpolationStringSet.add(httpSourceConfig.endpoint);
         Object.keys(httpSourceConfig.schemaHeaders || {}).forEach(headerName => {
             this.interpolationStringSet.add(headerName.toString());
         });
-        const schemaHeadersFactory = stringInterpolation.getInterpolatedHeadersFactory(httpSourceConfig.schemaHeaders || {});
-        if (httpSourceConfig.introspection) {
-            const headers = schemaHeadersFactory({
-                env: crossHelpers.process.env,
-            });
-            const sdlOrIntrospection = await utils.readFileOrUrl(httpSourceConfig.introspection, {
+        const schemaHeadersFactory = (0, string_interpolation_1.getInterpolatedHeadersFactory)(httpSourceConfig.schemaHeaders || {});
+        if (httpSourceConfig.source) {
+            const opts = {
                 cwd: this.baseDir,
                 allowUnknownExtensions: true,
                 importFn: this.importFn,
                 fetch: this.fetchFn,
                 logger: this.logger,
+            };
+            if (!(0, utils_1.isUrl)(httpSourceConfig.source)) {
+                return this.nonExecutableSchema.getWithSet(async () => {
+                    const sdlOrIntrospection = await (0, utils_1.readFile)(httpSourceConfig.source, opts);
+                    return this.getSchemaFromContent(sdlOrIntrospection);
+                });
+            }
+            const headers = schemaHeadersFactory({
+                env: cross_helpers_1.process.env,
+            });
+            const sdlOrIntrospection = await (0, utils_1.readUrl)(httpSourceConfig.source, {
+                ...opts,
                 headers,
             });
-            if (typeof sdlOrIntrospection === 'string') {
-                return graphql.buildSchema(sdlOrIntrospection);
-            }
-            else if (utils$1.isDocumentNode(sdlOrIntrospection)) {
-                return graphql.buildASTSchema(sdlOrIntrospection);
-            }
-            else if (sdlOrIntrospection.__schema) {
-                return graphql.buildClientSchema(sdlOrIntrospection);
-            }
-            throw new Error(`Invalid introspection data: ${crossHelpers.util.inspect(sdlOrIntrospection)}`);
+            return this.getSchemaFromContent(sdlOrIntrospection);
         }
         return this.nonExecutableSchema.getWithSet(() => {
-            const endpointFactory = stringInterpolation.getInterpolatedStringFactory(httpSourceConfig.endpoint);
+            const endpointFactory = (0, string_interpolation_1.getInterpolatedStringFactory)(httpSourceConfig.endpoint);
             const executor = this.urlLoader.getExecutorAsync(httpSourceConfig.endpoint, {
                 ...httpSourceConfig,
                 customFetch: this.fetchFn,
                 subscriptionsProtocol: httpSourceConfig.subscriptionsProtocol,
             });
-            return wrap.introspectSchema(function meshIntrospectionExecutor(params) {
+            return (0, wrap_1.schemaFromExecutor)(function meshIntrospectionExecutor(params) {
                 const resolverData = getResolverData(params);
                 return executor({
                     ...params,
@@ -108,16 +136,19 @@ class GraphQLHandler {
             });
         });
     }
-    async getCodeFirstSource({ schema: schemaConfig, }) {
+    async getCodeFirstSource({ source: schemaConfig, }) {
         if (schemaConfig.endsWith('.graphql')) {
-            const rawSDL = await utils.readFileOrUrl(schemaConfig, {
+            const rawSDL = await (0, utils_1.readFileOrUrl)(schemaConfig, {
                 cwd: this.baseDir,
                 allowUnknownExtensions: true,
                 importFn: this.importFn,
                 fetch: this.fetchFn,
                 logger: this.logger,
             });
-            const schema = graphql.buildSchema(rawSDL);
+            const schema = (0, graphql_1.buildSchema)(rawSDL, {
+                assumeValid: true,
+                assumeValidSDL: true,
+            });
             const { contextVariables } = this.getArgsAndContextVariables();
             return {
                 schema,
@@ -126,20 +157,26 @@ class GraphQLHandler {
         }
         else {
             // Loaders logic should be here somehow
-            const schemaOrStringOrDocumentNode = await utils.loadFromModuleExportExpression(schemaConfig, { cwd: this.baseDir, defaultExportName: 'schema', importFn: this.importFn });
+            const schemaOrStringOrDocumentNode = await (0, utils_1.loadFromModuleExportExpression)(schemaConfig, { cwd: this.baseDir, defaultExportName: 'schema', importFn: this.importFn });
             let schema;
-            if (schemaOrStringOrDocumentNode instanceof graphql.GraphQLSchema) {
+            if (schemaOrStringOrDocumentNode instanceof graphql_1.GraphQLSchema) {
                 schema = schemaOrStringOrDocumentNode;
             }
             else if (typeof schemaOrStringOrDocumentNode === 'string') {
-                schema = graphql.buildSchema(schemaOrStringOrDocumentNode);
+                schema = (0, graphql_1.buildSchema)(schemaOrStringOrDocumentNode, {
+                    assumeValid: true,
+                    assumeValidSDL: true,
+                });
             }
             else if (typeof schemaOrStringOrDocumentNode === 'object' &&
-                (schemaOrStringOrDocumentNode === null || schemaOrStringOrDocumentNode === void 0 ? void 0 : schemaOrStringOrDocumentNode.kind) === graphql.Kind.DOCUMENT) {
-                schema = graphql.buildASTSchema(schemaOrStringOrDocumentNode);
+                (schemaOrStringOrDocumentNode === null || schemaOrStringOrDocumentNode === void 0 ? void 0 : schemaOrStringOrDocumentNode.kind) === graphql_1.Kind.DOCUMENT) {
+                schema = (0, graphql_1.buildASTSchema)(schemaOrStringOrDocumentNode, {
+                    assumeValid: true,
+                    assumeValidSDL: true,
+                });
             }
             else {
-                throw new Error(`Provided file '${schemaConfig} exports an unknown type: ${crossHelpers.util.inspect(schemaOrStringOrDocumentNode)}': expected GraphQLSchema, SDL or DocumentNode.`);
+                throw new Error(`Provided file '${schemaConfig} exports an unknown type: ${cross_helpers_1.util.inspect(schemaOrStringOrDocumentNode)}': expected GraphQLSchema, SDL or DocumentNode.`);
             }
             const { contextVariables } = this.getArgsAndContextVariables();
             return {
@@ -179,7 +216,8 @@ class GraphQLHandler {
             throw error;
         };
     }
-    async getMeshSource() {
+    async getMeshSource({ fetchFn }) {
+        this.fetchFn = fetchFn;
         if ('sources' in this.config) {
             if (this.config.strategy === 'race') {
                 const schemaPromises = [];
@@ -192,7 +230,10 @@ class GraphQLHandler {
                     schemaPromises.push(this.getNonExecutableSchemaForHTTPSource(httpSourceConfig));
                     executorPromises.push(this.getExecutorForHTTPSourceConfig(httpSourceConfig));
                 }
-                const [schema, ...executors] = await Promise.all([Promise.race(schemaPromises), ...executorPromises]);
+                const [schema, ...executors] = await Promise.all([
+                    Promise.race(schemaPromises),
+                    ...executorPromises,
+                ]);
                 const executor = this.getRaceExecutor(executors);
                 const { contextVariables } = this.getArgsAndContextVariables();
                 return {
@@ -224,21 +265,21 @@ class GraphQLHandler {
                     throw error;
                 }
                 const executors = await Promise.all(executorPromises);
-                const parsedSelectionSet = utils$1.parseSelectionSet(this.config.strategyConfig.selectionSet);
+                const parsedSelectionSet = (0, utils_2.parseSelectionSet)(this.config.strategyConfig.selectionSet);
                 const valuePath = this.config.strategyConfig.value;
                 const highestValueExecutor = async function highestValueExecutor(executionRequest) {
-                    const operationAST = utils$1.getOperationASTFromRequest(executionRequest);
+                    const operationAST = (0, utils_2.getOperationASTFromRequest)(executionRequest);
                     operationAST.selectionSet.selections.push(...parsedSelectionSet.selections);
                     const results = await Promise.all(executors.map(executor => executor(executionRequest)));
                     let highestValue = -Infinity;
                     let resultWithHighestResult = results[0];
                     for (const result of results) {
-                        if (utils$1.isAsyncIterable(result)) {
+                        if ((0, utils_2.isAsyncIterable)(result)) {
                             console.warn('Incremental delivery is not supported currently');
                             return result;
                         }
                         else if (result.data != null) {
-                            const currentValue = lodashGet(result.data, valuePath);
+                            const currentValue = (0, lodash_get_1.default)(result.data, valuePath);
                             if (currentValue > highestValue) {
                                 resultWithHighestResult = result;
                                 highestValue = currentValue;
@@ -250,7 +291,7 @@ class GraphQLHandler {
                 const { contextVariables } = this.getArgsAndContextVariables();
                 return {
                     schema,
-                    executor: highestValueExecutor,
+                    executor: this.wrapExecutorToPassSourceNameAndDebug(highestValueExecutor),
                     // Batching doesn't make sense with fallback strategy
                     batch: false,
                     contextVariables,
@@ -292,24 +333,26 @@ class GraphQLHandler {
                 this.getExecutorForHTTPSourceConfig(this.config),
             ]);
             if (schemaResult.status === 'rejected') {
-                throw new Error(`Failed to fetch introspection from ${this.config.endpoint}: ${crossHelpers.util.inspect(schemaResult.reason)}`);
+                if (schemaResult.reason instanceof store_1.ValidationError) {
+                    throw schemaResult.reason;
+                }
+                throw new Error(`Failed to fetch introspection from ${this.config.endpoint}: ${cross_helpers_1.util.inspect(schemaResult.reason)}`);
             }
             if (executorResult.status === 'rejected') {
-                throw new Error(`Failed to create executor for ${this.config.endpoint}: ${crossHelpers.util.inspect(executorResult.reason)}`);
+                throw new Error(`Failed to create executor for ${this.config.endpoint}: ${cross_helpers_1.util.inspect(executorResult.reason)}`);
             }
             const { contextVariables } = this.getArgsAndContextVariables();
             return {
                 schema: schemaResult.value,
-                executor: executorResult.value,
+                executor: this.wrapExecutorToPassSourceNameAndDebug(executorResult.value),
                 batch: this.config.batch != null ? this.config.batch : true,
                 contextVariables,
             };
         }
-        else if ('schema' in this.config) {
+        else if ('source' in this.config) {
             return this.getCodeFirstSource(this.config);
         }
-        throw new Error(`Unexpected config: ${crossHelpers.util.inspect(this.config)}`);
+        throw new Error(`Unexpected config: ${cross_helpers_1.util.inspect(this.config)}`);
     }
 }
-
-module.exports = GraphQLHandler;
+exports.default = GraphQLHandler;

package/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/{index.mjs → esm/index.js}

@@ -1,13 +1,12 @@
-import { UrlLoader } from '@graphql-tools/url-loader';
-import { buildSchema, buildASTSchema, buildClientSchema, GraphQLSchema, Kind } from 'graphql';
-import { introspectSchema } from '@graphql-tools/wrap';
-import { readFileOrUrl, loadFromModuleExportExpression } from '@graphql-mesh/utils';
-import { isDocumentNode, parseSelectionSet, memoize1, getOperationASTFromRequest, isAsyncIterable } from '@graphql-tools/utils';
-import { PredefinedProxyOptions } from '@graphql-mesh/store';
+import { buildASTSchema, buildClientSchema, buildSchema, GraphQLSchema, Kind, print, } from 'graphql';
 import lodashGet from 'lodash.get';
-import { parseInterpolationStrings, getInterpolatedStringFactory, getInterpolatedHeadersFactory } from '@graphql-mesh/string-interpolation';
 import { process, util } from '@graphql-mesh/cross-helpers';
-
+import { PredefinedProxyOptions, ValidationError } from '@graphql-mesh/store';
+import { getInterpolatedHeadersFactory, getInterpolatedStringFactory, parseInterpolationStrings, } from '@graphql-mesh/string-interpolation';
+import { isUrl, loadFromModuleExportExpression, readFile, readFileOrUrl, readUrl, } from '@graphql-mesh/utils';
+import { UrlLoader } from '@graphql-tools/url-loader';
+import { getOperationASTFromRequest, isAsyncIterable, isDocumentNode, memoize1, parseSelectionSet, } from '@graphql-tools/utils';
+import { schemaFromExecutor } from '@graphql-tools/wrap';
 const getResolverData = memoize1(function getResolverData(params) {
     return {
         root: params.rootValue,
@@ -16,13 +15,13 @@ const getResolverData = memoize1(function getResolverData(params) {
         env: process.env,
     };
 });
-class GraphQLHandler {
-    constructor({ config, baseDir, fetchFn, store, importFn, logger, }) {
+export default class GraphQLHandler {
+    constructor({ name, config, baseDir, store, importFn, logger, }) {
         this.urlLoader = new UrlLoader();
         this.interpolationStringSet = new Set();
+        this.name = name;
         this.config = config;
         this.baseDir = baseDir;
-        this.fetchFn = fetchFn;
         this.nonExecutableSchema = store.proxy('introspectionSchema', PredefinedProxyOptions.GraphQLSchemaWithDiffing);
         this.importFn = importFn;
         this.logger = logger;
@@ -30,6 +29,16 @@ class GraphQLHandler {
     getArgsAndContextVariables() {
         return parseInterpolationStrings(this.interpolationStringSet);
     }
+    wrapExecutorToPassSourceNameAndDebug(executor) {
+        const sourceName = this.name;
+        const logger = this.logger;
+        return function executorWithSourceName(executionRequest) {
+            logger.debug(() => `Sending GraphQL Request: `, print(executionRequest.document));
+            executionRequest.info = executionRequest.info || {};
+            executionRequest.info.sourceName = sourceName;
+            return executor(executionRequest);
+        };
+    }
     async getExecutorForHTTPSourceConfig(httpSourceConfig) {
         const { endpoint, operationHeaders = {} } = httpSourceConfig;
         this.interpolationStringSet.add(endpoint);
@@ -55,34 +64,54 @@ class GraphQLHandler {
             });
         };
     }
+    getSchemaFromContent(sdlOrIntrospection) {
+        if (typeof sdlOrIntrospection === 'string') {
+            return buildSchema(sdlOrIntrospection, {
+                assumeValid: true,
+                assumeValidSDL: true,
+            });
+        }
+        else if (isDocumentNode(sdlOrIntrospection)) {
+            return buildASTSchema(sdlOrIntrospection, {
+                assumeValid: true,
+                assumeValidSDL: true,
+            });
+        }
+        else if (sdlOrIntrospection.__schema) {
+            return buildClientSchema(sdlOrIntrospection, {
+                assumeValid: true,
+            });
+        }
+        throw new Error(`Invalid introspection data: ${util.inspect(sdlOrIntrospection)}`);
+    }
     async getNonExecutableSchemaForHTTPSource(httpSourceConfig) {
         this.interpolationStringSet.add(httpSourceConfig.endpoint);
         Object.keys(httpSourceConfig.schemaHeaders || {}).forEach(headerName => {
             this.interpolationStringSet.add(headerName.toString());
         });
         const schemaHeadersFactory = getInterpolatedHeadersFactory(httpSourceConfig.schemaHeaders || {});
-        if (httpSourceConfig.introspection) {
-            const headers = schemaHeadersFactory({
-                env: process.env,
-            });
-            const sdlOrIntrospection = await readFileOrUrl(httpSourceConfig.introspection, {
+        if (httpSourceConfig.source) {
+            const opts = {
                 cwd: this.baseDir,
                 allowUnknownExtensions: true,
                 importFn: this.importFn,
                 fetch: this.fetchFn,
                 logger: this.logger,
+            };
+            if (!isUrl(httpSourceConfig.source)) {
+                return this.nonExecutableSchema.getWithSet(async () => {
+                    const sdlOrIntrospection = await readFile(httpSourceConfig.source, opts);
+                    return this.getSchemaFromContent(sdlOrIntrospection);
+                });
+            }
+            const headers = schemaHeadersFactory({
+                env: process.env,
+            });
+            const sdlOrIntrospection = await readUrl(httpSourceConfig.source, {
+                ...opts,
                 headers,
             });
-            if (typeof sdlOrIntrospection === 'string') {
-                return buildSchema(sdlOrIntrospection);
-            }
-            else if (isDocumentNode(sdlOrIntrospection)) {
-                return buildASTSchema(sdlOrIntrospection);
-            }
-            else if (sdlOrIntrospection.__schema) {
-                return buildClientSchema(sdlOrIntrospection);
-            }
-            throw new Error(`Invalid introspection data: ${util.inspect(sdlOrIntrospection)}`);
+            return this.getSchemaFromContent(sdlOrIntrospection);
         }
         return this.nonExecutableSchema.getWithSet(() => {
             const endpointFactory = getInterpolatedStringFactory(httpSourceConfig.endpoint);
@@ -91,7 +120,7 @@ class GraphQLHandler {
                 customFetch: this.fetchFn,
                 subscriptionsProtocol: httpSourceConfig.subscriptionsProtocol,
             });
-            return introspectSchema(function meshIntrospectionExecutor(params) {
+            return schemaFromExecutor(function meshIntrospectionExecutor(params) {
                 const resolverData = getResolverData(params);
                 return executor({
                     ...params,
@@ -104,7 +133,7 @@ class GraphQLHandler {
             });
         });
     }
-    async getCodeFirstSource({ schema: schemaConfig, }) {
+    async getCodeFirstSource({ source: schemaConfig, }) {
         if (schemaConfig.endsWith('.graphql')) {
             const rawSDL = await readFileOrUrl(schemaConfig, {
                 cwd: this.baseDir,
@@ -113,7 +142,10 @@ class GraphQLHandler {
                 fetch: this.fetchFn,
                 logger: this.logger,
             });
-            const schema = buildSchema(rawSDL);
+            const schema = buildSchema(rawSDL, {
+                assumeValid: true,
+                assumeValidSDL: true,
+            });
             const { contextVariables } = this.getArgsAndContextVariables();
             return {
                 schema,
@@ -128,11 +160,17 @@ class GraphQLHandler {
                 schema = schemaOrStringOrDocumentNode;
             }
             else if (typeof schemaOrStringOrDocumentNode === 'string') {
-                schema = buildSchema(schemaOrStringOrDocumentNode);
+                schema = buildSchema(schemaOrStringOrDocumentNode, {
+                    assumeValid: true,
+                    assumeValidSDL: true,
+                });
             }
             else if (typeof schemaOrStringOrDocumentNode === 'object' &&
                 (schemaOrStringOrDocumentNode === null || schemaOrStringOrDocumentNode === void 0 ? void 0 : schemaOrStringOrDocumentNode.kind) === Kind.DOCUMENT) {
-                schema = buildASTSchema(schemaOrStringOrDocumentNode);
+                schema = buildASTSchema(schemaOrStringOrDocumentNode, {
+                    assumeValid: true,
+                    assumeValidSDL: true,
+                });
             }
             else {
                 throw new Error(`Provided file '${schemaConfig} exports an unknown type: ${util.inspect(schemaOrStringOrDocumentNode)}': expected GraphQLSchema, SDL or DocumentNode.`);
@@ -175,7 +213,8 @@ class GraphQLHandler {
             throw error;
         };
     }
-    async getMeshSource() {
+    async getMeshSource({ fetchFn }) {
+        this.fetchFn = fetchFn;
         if ('sources' in this.config) {
             if (this.config.strategy === 'race') {
                 const schemaPromises = [];
@@ -188,7 +227,10 @@ class GraphQLHandler {
                     schemaPromises.push(this.getNonExecutableSchemaForHTTPSource(httpSourceConfig));
                     executorPromises.push(this.getExecutorForHTTPSourceConfig(httpSourceConfig));
                 }
-                const [schema, ...executors] = await Promise.all([Promise.race(schemaPromises), ...executorPromises]);
+                const [schema, ...executors] = await Promise.all([
+                    Promise.race(schemaPromises),
+                    ...executorPromises,
+                ]);
                 const executor = this.getRaceExecutor(executors);
                 const { contextVariables } = this.getArgsAndContextVariables();
                 return {
@@ -246,7 +288,7 @@ class GraphQLHandler {
                 const { contextVariables } = this.getArgsAndContextVariables();
                 return {
                     schema,
-                    executor: highestValueExecutor,
+                    executor: this.wrapExecutorToPassSourceNameAndDebug(highestValueExecutor),
                     // Batching doesn't make sense with fallback strategy
                     batch: false,
                     contextVariables,
@@ -288,6 +330,9 @@ class GraphQLHandler {
                 this.getExecutorForHTTPSourceConfig(this.config),
             ]);
             if (schemaResult.status === 'rejected') {
+                if (schemaResult.reason instanceof ValidationError) {
+                    throw schemaResult.reason;
+                }
                 throw new Error(`Failed to fetch introspection from ${this.config.endpoint}: ${util.inspect(schemaResult.reason)}`);
             }
             if (executorResult.status === 'rejected') {
@@ -296,16 +341,14 @@ class GraphQLHandler {
             const { contextVariables } = this.getArgsAndContextVariables();
             return {
                 schema: schemaResult.value,
-                executor: executorResult.value,
+                executor: this.wrapExecutorToPassSourceNameAndDebug(executorResult.value),
                 batch: this.config.batch != null ? this.config.batch : true,
                 contextVariables,
             };
         }
-        else if ('schema' in this.config) {
+        else if ('source' in this.config) {
             return this.getCodeFirstSource(this.config);
         }
         throw new Error(`Unexpected config: ${util.inspect(this.config)}`);
     }
 }
-
-export default GraphQLHandler;

package/package.json

@@ -1,22 +1,22 @@
 {
   "name": "@graphql-mesh/graphql",
-  "version": "1.0.0-alpha-3fc47d119.0",
+  "version": "1.0.0-alpha-20230420181317-a95037648",
   "sideEffects": false,
   "peerDependencies": {
-    "@graphql-mesh/types": "0.79.0-alpha-3fc47d119.0",
-    "@graphql-mesh/utils": "1.0.0-alpha-3fc47d119.0",
-    "graphql": "*"
+    "@graphql-mesh/cross-helpers": "^0.3.4",
+    "@graphql-mesh/store": "1.0.0-alpha-20230420181317-a95037648",
+    "@graphql-mesh/types": "1.0.0-alpha-20230420181317-a95037648",
+    "@graphql-mesh/utils": "1.0.0-alpha-20230420181317-a95037648",
+    "@graphql-tools/utils": "^9.2.1",
+    "graphql": "*",
+    "tslib": "^2.4.0"
   },
   "dependencies": {
-    "@graphql-mesh/cross-helpers": "0.2.0",
-    "@graphql-mesh/store": "1.0.0-alpha-3fc47d119.0",
-    "@graphql-mesh/string-interpolation": "0.3.0",
-    "@graphql-tools/delegate": "8.8.0",
-    "@graphql-tools/url-loader": "7.13.0",
-    "@graphql-tools/utils": "8.8.0",
-    "@graphql-tools/wrap": "8.5.0",
-    "lodash.get": "4.4.2",
-    "tslib": "^2.4.0"
+    "@graphql-mesh/string-interpolation": "0.4.4",
+    "@graphql-tools/delegate": "9.0.32",
+    "@graphql-tools/url-loader": "7.17.18",
+    "@graphql-tools/wrap": "9.4.2",
+    "lodash.get": "4.4.2"
   },
   "repository": {
     "type": "git",
@@ -24,21 +24,28 @@
     "directory": "packages/handlers/graphql"
   },
   "license": "MIT",
-  "main": "index.js",
-  "module": "index.mjs",
-  "typings": "index.d.ts",
+  "main": "cjs/index.js",
+  "module": "esm/index.js",
+  "typings": "typings/index.d.ts",
   "typescript": {
-    "definition": "index.d.ts"
+    "definition": "typings/index.d.ts"
   },
+  "type": "module",
   "exports": {
     ".": {
-      "require": "./index.js",
-      "import": "./index.mjs"
-    },
-    "./*": {
-      "require": "./*.js",
-      "import": "./*.mjs"
+      "require": {
+        "types": "./typings/index.d.cts",
+        "default": "./cjs/index.js"
+      },
+      "import": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      },
+      "default": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      }
     },
     "./package.json": "./package.json"
   }
-}
+}

package/typings/index.d.cts

@@ -0,0 +1,23 @@
+import { GraphQLSchema } from 'graphql';
+import { GetMeshSourcePayload, MeshHandler, MeshHandlerOptions, MeshSource, YamlConfig } from '@graphql-mesh/types';
+export default class GraphQLHandler implements MeshHandler {
+    private name;
+    private config;
+    private baseDir;
+    private nonExecutableSchema;
+    private importFn;
+    private fetchFn;
+    private logger;
+    private urlLoader;
+    constructor({ name, config, baseDir, store, importFn, logger, }: MeshHandlerOptions<YamlConfig.Handler['graphql']>);
+    private interpolationStringSet;
+    private getArgsAndContextVariables;
+    private wrapExecutorToPassSourceNameAndDebug;
+    getExecutorForHTTPSourceConfig(httpSourceConfig: YamlConfig.GraphQLHandlerHTTPConfiguration): Promise<MeshSource['executor']>;
+    private getSchemaFromContent;
+    getNonExecutableSchemaForHTTPSource(httpSourceConfig: YamlConfig.GraphQLHandlerHTTPConfiguration): Promise<GraphQLSchema>;
+    getCodeFirstSource({ source: schemaConfig, }: YamlConfig.GraphQLHandlerCodeFirstConfiguration): Promise<MeshSource>;
+    getRaceExecutor(executors: MeshSource['executor'][]): MeshSource['executor'];
+    getFallbackExecutor(executors: MeshSource['executor'][]): MeshSource['executor'];
+    getMeshSource({ fetchFn }: GetMeshSourcePayload): Promise<MeshSource>;
+}

package/{index.d.ts → typings/index.d.ts}

@@ -1,6 +1,7 @@
-import { GetMeshSourceOptions, MeshHandler, MeshSource, YamlConfig } from '@graphql-mesh/types';
 import { GraphQLSchema } from 'graphql';
+import { GetMeshSourcePayload, MeshHandler, MeshHandlerOptions, MeshSource, YamlConfig } from '@graphql-mesh/types';
 export default class GraphQLHandler implements MeshHandler {
+    private name;
     private config;
     private baseDir;
     private nonExecutableSchema;
@@ -8,13 +9,15 @@ export default class GraphQLHandler implements MeshHandler {
     private fetchFn;
     private logger;
     private urlLoader;
-    constructor({ config, baseDir, fetchFn, store, importFn, logger, }: GetMeshSourceOptions<YamlConfig.Handler['graphql']>);
+    constructor({ name, config, baseDir, store, importFn, logger, }: MeshHandlerOptions<YamlConfig.Handler['graphql']>);
     private interpolationStringSet;
     private getArgsAndContextVariables;
+    private wrapExecutorToPassSourceNameAndDebug;
     getExecutorForHTTPSourceConfig(httpSourceConfig: YamlConfig.GraphQLHandlerHTTPConfiguration): Promise<MeshSource['executor']>;
+    private getSchemaFromContent;
     getNonExecutableSchemaForHTTPSource(httpSourceConfig: YamlConfig.GraphQLHandlerHTTPConfiguration): Promise<GraphQLSchema>;
-    getCodeFirstSource({ schema: schemaConfig, }: YamlConfig.GraphQLHandlerCodeFirstConfiguration): Promise<MeshSource>;
+    getCodeFirstSource({ source: schemaConfig, }: YamlConfig.GraphQLHandlerCodeFirstConfiguration): Promise<MeshSource>;
     getRaceExecutor(executors: MeshSource['executor'][]): MeshSource['executor'];
     getFallbackExecutor(executors: MeshSource['executor'][]): MeshSource['executor'];
-    getMeshSource(): Promise<MeshSource>;
+    getMeshSource({ fetchFn }: GetMeshSourcePayload): Promise<MeshSource>;
 }