@graphql-tools/delegate 8.8.2-alpha-33fb2950.0 → 8.8.2-alpha-420b7771.0

package/cjs/checkResultAndHandleErrors.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mergeDataAndErrors = exports.checkResultAndHandleErrors = void 0;
-const graphql_1 = require("@graphql-tools/graphql");
+const graphql_1 = require("graphql");
 const utils_1 = require("@graphql-tools/utils");
 const resolveExternalValue_js_1 = require("./resolveExternalValue.js");
 function checkResultAndHandleErrors(result, delegationContext) {

package/cjs/createRequest.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createRequest = exports.getDelegatingOperation = void 0;
-const graphql_1 = require("@graphql-tools/graphql");
+const graphql_1 = require("graphql");
 const utils_1 = require("@graphql-tools/utils");
 function getDelegatingOperation(parentType, schema) {
     if (parentType === schema.getMutationType()) {

package/cjs/defaultMergedResolver.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.defaultMergedResolver = void 0;
-const graphql_1 = require("@graphql-tools/graphql");
+const graphql_1 = require("graphql");
 const utils_1 = require("@graphql-tools/utils");
 const resolveExternalValue_js_1 = require("./resolveExternalValue.js");
 const mergeFields_js_1 = require("./mergeFields.js");

package/cjs/delegateToSchema.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createDefaultExecutor = exports.delegateRequest = exports.delegateToSchema = void 0;
-const graphql_1 = require("@graphql-tools/graphql");
+const graphql_1 = require("graphql");
 const value_or_promise_1 = require("value-or-promise");
 const batch_execute_1 = require("@graphql-tools/batch-execute");
 const utils_1 = require("@graphql-tools/utils");

package/cjs/finalizeGatewayRequest.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.finalizeGatewayRequest = void 0;
-const graphql_1 = require("@graphql-tools/graphql");
+const graphql_1 = require("graphql");
 const utils_1 = require("@graphql-tools/utils");
 const getDocumentMetadata_js_1 = require("./getDocumentMetadata.js");
 function finalizeGatewayDocument(targetSchema, fragments, operations) {

package/cjs/getDocumentMetadata.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getDocumentMetadata = void 0;
-const graphql_1 = require("@graphql-tools/graphql");
+const graphql_1 = require("graphql");
 function getDocumentMetadata(document) {
     const operations = [];
     const fragments = [];

package/cjs/mergeFields.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mergeFields = exports.getUnpathedErrors = exports.getSubschema = exports.annotateExternalObject = exports.isExternalObject = void 0;
-const graphql_1 = require("@graphql-tools/graphql");
+const graphql_1 = require("graphql");
 const utils_1 = require("@graphql-tools/utils");
 const symbols_js_1 = require("./symbols.js");
 function isExternalObject(data) {

package/cjs/prepareGatewayDocument.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.prepareGatewayDocument = void 0;
-const graphql_1 = require("@graphql-tools/graphql");
+const graphql_1 = require("graphql");
 const utils_1 = require("@graphql-tools/utils");
 const getDocumentMetadata_js_1 = require("./getDocumentMetadata.js");
 function prepareGatewayDocument(originalDocument, transformedSchema, returnType, infoSchema) {

package/cjs/resolveExternalValue.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveExternalValue = void 0;
-const graphql_1 = require("@graphql-tools/graphql");
+const graphql_1 = require("graphql");
 const utils_1 = require("@graphql-tools/utils");
 const mergeFields_js_1 = require("./mergeFields.js");
 function resolveExternalValue(result, unpathedErrors, subschema, context, info, returnType = getReturnType(info), skipTypeMerging) {

package/esm/checkResultAndHandleErrors.js

@@ -1,4 +1,4 @@
-import { responsePathAsArray, locatedError, } from '@graphql-tools/graphql';
+import { responsePathAsArray, locatedError } from 'graphql';
 import { AggregateError, getResponseKeyFromInfo, relocatedError } from '@graphql-tools/utils';
 import { resolveExternalValue } from './resolveExternalValue.js';
 export function checkResultAndHandleErrors(result, delegationContext) {

package/esm/createRequest.js

@@ -1,4 +1,4 @@
-import { Kind, typeFromAST, } from '@graphql-tools/graphql';
+import { Kind, typeFromAST, } from 'graphql';
 import { createVariableNameGenerator, serializeInputValue, updateArgument, } from '@graphql-tools/utils';
 export function getDelegatingOperation(parentType, schema) {
     if (parentType === schema.getMutationType()) {

package/esm/defaultMergedResolver.js

@@ -1,4 +1,4 @@
-import { defaultFieldResolver } from '@graphql-tools/graphql';
+import { defaultFieldResolver } from 'graphql';
 import { getResponseKeyFromInfo } from '@graphql-tools/utils';
 import { resolveExternalValue } from './resolveExternalValue.js';
 import { getSubschema, getUnpathedErrors, isExternalObject } from './mergeFields.js';

package/esm/delegateToSchema.js

@@ -1,4 +1,4 @@
-import { validate, subscribe, execute, } from '@graphql-tools/graphql';
+import { validate, subscribe, execute, } from 'graphql';
 import { ValueOrPromise } from 'value-or-promise';
 import { getBatchingExecutor } from '@graphql-tools/batch-execute';
 import { mapAsyncIterator, AggregateError, isAsyncIterable, getDefinedRootType, memoize1, getOperationASTFromRequest, } from '@graphql-tools/utils';

package/esm/finalizeGatewayRequest.js

@@ -1,4 +1,4 @@
-import { getNamedType, isAbstractType, isInterfaceType, isObjectType, Kind, TypeInfo, TypeNameMetaFieldDef, versionInfo as graphqlVersionInfo, visit, visitWithTypeInfo, } from '@graphql-tools/graphql';
+import { getNamedType, isAbstractType, isInterfaceType, isObjectType, Kind, TypeInfo, TypeNameMetaFieldDef, versionInfo as graphqlVersionInfo, visit, visitWithTypeInfo, } from 'graphql';
 import { getDefinedRootType, serializeInputValue, updateArgument, createVariableNameGenerator, implementsAbstractType, inspect, } from '@graphql-tools/utils';
 import { getDocumentMetadata } from './getDocumentMetadata.js';
 function finalizeGatewayDocument(targetSchema, fragments, operations) {

package/esm/getDocumentMetadata.js

@@ -1,4 +1,4 @@
-import { Kind } from '@graphql-tools/graphql';
+import { Kind } from 'graphql';
 export function getDocumentMetadata(document) {
     const operations = [];
     const fragments = [];

package/esm/mergeFields.js

@@ -1,4 +1,4 @@
-import { responsePathAsArray, GraphQLError, locatedError, } from '@graphql-tools/graphql';
+import { responsePathAsArray, GraphQLError, locatedError, } from 'graphql';
 import { collectFields, relocatedError } from '@graphql-tools/utils';
 import { FIELD_SUBSCHEMA_MAP_SYMBOL, OBJECT_SUBSCHEMA_SYMBOL, UNPATHED_ERRORS_SYMBOL } from './symbols.js';
 export function isExternalObject(data) {

package/esm/prepareGatewayDocument.js

@@ -1,4 +1,4 @@
-import { Kind, TypeInfo, getNamedType, isAbstractType, isInterfaceType, visit, visitWithTypeInfo, isObjectType, } from '@graphql-tools/graphql';
+import { Kind, TypeInfo, getNamedType, isAbstractType, isInterfaceType, visit, visitWithTypeInfo, isObjectType, } from 'graphql';
 import { implementsAbstractType, getRootTypeNames, memoize2 } from '@graphql-tools/utils';
 import { getDocumentMetadata } from './getDocumentMetadata.js';
 export function prepareGatewayDocument(originalDocument, transformedSchema, returnType, infoSchema) {

package/esm/resolveExternalValue.js

@@ -1,4 +1,4 @@
-import { getNullableType, isCompositeType, isListType, isAbstractType, locatedError, } from '@graphql-tools/graphql';
+import { getNullableType, isCompositeType, isListType, isAbstractType, locatedError, } from 'graphql';
 import { AggregateError } from '@graphql-tools/utils';
 import { annotateExternalObject, isExternalObject, mergeFields } from './mergeFields.js';
 export function resolveExternalValue(result, unpathedErrors, subschema, context, info, returnType = getReturnType(info), skipTypeMerging) {

package/package.json

@@ -1,13 +1,15 @@
 {
   "name": "@graphql-tools/delegate",
-  "version": "8.8.2-alpha-33fb2950.0",
+  "version": "8.8.2-alpha-420b7771.0",
   "description": "A set of utils for faster development of GraphQL tools",
   "sideEffects": false,
+  "peerDependencies": {
+    "graphql": "^14.0.0 || ^15.0.0 || ^16.0.0 || ^17.0.0"
+  },
   "dependencies": {
-    "@graphql-tools/batch-execute": "8.5.2-alpha-33fb2950.0",
-    "@graphql-tools/schema": "8.5.2-alpha-33fb2950.0",
-    "@graphql-tools/utils": "8.9.1-alpha-33fb2950.0",
-    "@graphql-tools/graphql": "0.1.0-alpha-33fb2950.0",
+    "@graphql-tools/batch-execute": "8.5.2-alpha-420b7771.0",
+    "@graphql-tools/schema": "8.5.2-alpha-420b7771.0",
+    "@graphql-tools/utils": "8.9.1-alpha-420b7771.0",
     "dataloader": "2.1.0",
     "tslib": "~2.4.0",
     "value-or-promise": "1.0.11"
@@ -28,7 +30,7 @@
   "exports": {
     ".": {
       "require": {
-        "types": "./typings/index.d.ts",
+        "types": "./typings/index.d.cts",
         "default": "./cjs/index.js"
       },
       "import": {
@@ -42,7 +44,7 @@
     },
     "./*": {
       "require": {
-        "types": "./typings/*.d.ts",
+        "types": "./typings/*.d.cts",
         "default": "./cjs/*.js"
       },
       "import": {

package/typings/Subschema.d.cts

@@ -0,0 +1,19 @@
+import { GraphQLSchema } from 'graphql';
+import { SubschemaConfig, Transform, MergedTypeConfig, CreateProxyingResolverFn, BatchingOptions } from './types.js';
+import { Executor } from '@graphql-tools/utils';
+export declare function isSubschema(value: any): value is Subschema;
+interface ISubschema<K = any, V = any, C = K, TContext = Record<string, any>> extends SubschemaConfig<K, V, C, TContext> {
+    transformedSchema: GraphQLSchema;
+}
+export declare class Subschema<K = any, V = any, C = K, TContext = Record<string, any>> implements ISubschema<K, V, C, TContext> {
+    schema: GraphQLSchema;
+    executor?: Executor<TContext>;
+    batch?: boolean;
+    batchingOptions?: BatchingOptions<K, V, C>;
+    createProxyingResolver?: CreateProxyingResolverFn<TContext>;
+    transforms: Array<Transform<any, TContext>>;
+    transformedSchema: GraphQLSchema;
+    merge?: Record<string, MergedTypeConfig<any, any, TContext>>;
+    constructor(config: SubschemaConfig<K, V, C, TContext>);
+}
+export {};

package/typings/Subschema.d.ts

@@ -1,4 +1,4 @@
-import { GraphQLSchema } from '@graphql-tools/graphql';
+import { GraphQLSchema } from 'graphql';
 import { SubschemaConfig, Transform, MergedTypeConfig, CreateProxyingResolverFn, BatchingOptions } from './types.js';
 import { Executor } from '@graphql-tools/utils';
 export declare function isSubschema(value: any): value is Subschema;

package/typings/Transformer.d.cts

@@ -0,0 +1,10 @@
+import { ExecutionRequest, ExecutionResult } from '@graphql-tools/utils';
+import { DelegationContext } from './types.js';
+export declare class Transformer<TContext extends Record<string, any> = Record<string, any>> {
+    private transformations;
+    private delegationContext;
+    constructor(context: DelegationContext<TContext>);
+    private addTransform;
+    transformRequest(originalRequest: ExecutionRequest): ExecutionRequest;
+    transformResult(originalResult: ExecutionResult): any;
+}

package/typings/applySchemaTransforms.d.cts

@@ -0,0 +1,3 @@
+import { GraphQLSchema } from 'graphql';
+import { SubschemaConfig } from './types.js';
+export declare function applySchemaTransforms(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig<any, any, any, any>, transformedSchema?: GraphQLSchema): GraphQLSchema;

package/typings/applySchemaTransforms.d.ts

@@ -1,3 +1,3 @@
-import { GraphQLSchema } from '@graphql-tools/graphql';
+import { GraphQLSchema } from 'graphql';
 import { SubschemaConfig } from './types.js';
 export declare function applySchemaTransforms(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig<any, any, any, any>, transformedSchema?: GraphQLSchema): GraphQLSchema;

package/typings/checkResultAndHandleErrors.d.cts

@@ -0,0 +1,8 @@
+import { GraphQLError } from 'graphql';
+import { ExecutionResult } from '@graphql-tools/utils';
+import { DelegationContext } from './types.js';
+export declare function checkResultAndHandleErrors<TContext extends Record<string, any>>(result: ExecutionResult, delegationContext: DelegationContext<TContext>): any;
+export declare function mergeDataAndErrors(data: any, errors: ReadonlyArray<GraphQLError>, path: Array<string | number> | undefined, onLocatedError?: (originalError: GraphQLError) => GraphQLError, index?: number): {
+    data: any;
+    unpathedErrors: Array<GraphQLError>;
+};

package/typings/checkResultAndHandleErrors.d.ts

@@ -1,4 +1,4 @@
-import { GraphQLError } from '@graphql-tools/graphql';
+import { GraphQLError } from 'graphql';
 import { ExecutionResult } from '@graphql-tools/utils';
 import { DelegationContext } from './types.js';
 export declare function checkResultAndHandleErrors<TContext extends Record<string, any>>(result: ExecutionResult, delegationContext: DelegationContext<TContext>): any;

package/typings/createRequest.d.cts

@@ -0,0 +1,5 @@
+import { GraphQLSchema, GraphQLObjectType, OperationTypeNode } from 'graphql';
+import { ExecutionRequest } from '@graphql-tools/utils';
+import { ICreateRequest } from './types.js';
+export declare function getDelegatingOperation(parentType: GraphQLObjectType, schema: GraphQLSchema): OperationTypeNode;
+export declare function createRequest({ sourceSchema, sourceParentType, sourceFieldName, fragments, variableDefinitions, variableValues, targetRootValue, targetOperationName, targetOperation, targetFieldName, selectionSet, fieldNodes, context, info, }: ICreateRequest): ExecutionRequest;

package/typings/createRequest.d.ts

@@ -1,4 +1,4 @@
-import { GraphQLSchema, GraphQLObjectType, OperationTypeNode } from '@graphql-tools/graphql';
+import { GraphQLSchema, GraphQLObjectType, OperationTypeNode } from 'graphql';
 import { ExecutionRequest } from '@graphql-tools/utils';
 import { ICreateRequest } from './types.js';
 export declare function getDelegatingOperation(parentType: GraphQLObjectType, schema: GraphQLSchema): OperationTypeNode;

package/typings/defaultMergedResolver.d.cts

@@ -0,0 +1,9 @@
+import { GraphQLResolveInfo } from 'graphql';
+import { ExternalObject } from './types.js';
+/**
+ * Resolver that knows how to:
+ * a) handle aliases for proxied schemas
+ * b) handle errors from proxied schemas
+ * c) handle external to internal enum conversion
+ */
+export declare function defaultMergedResolver(parent: ExternalObject, args: Record<string, any>, context: Record<string, any>, info: GraphQLResolveInfo): any;

package/typings/defaultMergedResolver.d.ts

@@ -1,4 +1,4 @@
-import { GraphQLResolveInfo } from '@graphql-tools/graphql';
+import { GraphQLResolveInfo } from 'graphql';
 import { ExternalObject } from './types.js';
 /**
  * Resolver that knows how to:

package/typings/delegateToSchema.d.cts

@@ -0,0 +1,6 @@
+import { GraphQLSchema } from 'graphql';
+import { Executor } from '@graphql-tools/utils';
+import { IDelegateToSchemaOptions, IDelegateRequestOptions } from './types.js';
+export declare function delegateToSchema<TContext extends Record<string, any> = Record<string, any>, TArgs extends Record<string, any> = any>(options: IDelegateToSchemaOptions<TContext, TArgs>): any;
+export declare function delegateRequest<TContext extends Record<string, any> = Record<string, any>, TArgs extends Record<string, any> = any>(options: IDelegateRequestOptions<TContext, TArgs>): any;
+export declare const createDefaultExecutor: (schema: GraphQLSchema) => Executor;

package/typings/delegateToSchema.d.ts

@@ -1,4 +1,4 @@
-import { GraphQLSchema } from '@graphql-tools/graphql';
+import { GraphQLSchema } from 'graphql';
 import { Executor } from '@graphql-tools/utils';
 import { IDelegateToSchemaOptions, IDelegateRequestOptions } from './types.js';
 export declare function delegateToSchema<TContext extends Record<string, any> = Record<string, any>, TArgs extends Record<string, any> = any>(options: IDelegateToSchemaOptions<TContext, TArgs>): any;

package/typings/finalizeGatewayRequest.d.cts

@@ -0,0 +1,3 @@
+import { ExecutionRequest } from '@graphql-tools/utils';
+import { DelegationContext } from './types.js';
+export declare function finalizeGatewayRequest<TContext>(originalRequest: ExecutionRequest, delegationContext: DelegationContext<TContext>): ExecutionRequest;

package/typings/getDocumentMetadata.d.cts

@@ -0,0 +1,6 @@
+import { DocumentNode, FragmentDefinitionNode, OperationDefinitionNode } from 'graphql';
+export declare function getDocumentMetadata(document: DocumentNode): {
+    operations: Array<OperationDefinitionNode>;
+    fragments: Array<FragmentDefinitionNode>;
+    fragmentNames: Set<string>;
+};

package/typings/getDocumentMetadata.d.ts

@@ -1,4 +1,4 @@
-import { DocumentNode, FragmentDefinitionNode, OperationDefinitionNode } from '@graphql-tools/graphql';
+import { DocumentNode, FragmentDefinitionNode, OperationDefinitionNode } from 'graphql';
 export declare function getDocumentMetadata(document: DocumentNode): {
     operations: Array<OperationDefinitionNode>;
     fragments: Array<FragmentDefinitionNode>;

package/typings/index.d.cts

@@ -0,0 +1,10 @@
+export * from './Subschema.js';
+export * from './Transformer.js';
+export * from './applySchemaTransforms.js';
+export * from './createRequest.js';
+export * from './defaultMergedResolver.js';
+export * from './delegateToSchema.js';
+export * from './mergeFields.js';
+export * from './resolveExternalValue.js';
+export * from './subschemaConfig.js';
+export * from './types.js';

package/typings/mergeFields.d.cts

@@ -0,0 +1,8 @@
+import { GraphQLResolveInfo, GraphQLError, GraphQLSchema } from 'graphql';
+import { ExternalObject, MergedTypeInfo, SubschemaConfig } from './types.js';
+import { Subschema } from './Subschema.js';
+export declare function isExternalObject(data: any): data is ExternalObject;
+export declare function annotateExternalObject<TContext>(object: any, errors: Array<GraphQLError>, subschema: GraphQLSchema | SubschemaConfig<any, any, any, TContext> | undefined, subschemaMap: Record<string, GraphQLSchema | SubschemaConfig<any, any, any, Record<string, any>>>): ExternalObject;
+export declare function getSubschema(object: ExternalObject, responseKey: string): GraphQLSchema | SubschemaConfig;
+export declare function getUnpathedErrors(object: ExternalObject): Array<GraphQLError>;
+export declare function mergeFields<TContext>(mergedTypeInfo: MergedTypeInfo, object: any, sourceSubschema: Subschema<any, any, any, TContext>, context: any, info: GraphQLResolveInfo): Promise<any>;

package/typings/mergeFields.d.ts

@@ -1,4 +1,4 @@
-import { GraphQLResolveInfo, GraphQLError, GraphQLSchema } from '@graphql-tools/graphql';
+import { GraphQLResolveInfo, GraphQLError, GraphQLSchema } from 'graphql';
 import { ExternalObject, MergedTypeInfo, SubschemaConfig } from './types.js';
 import { Subschema } from './Subschema.js';
 export declare function isExternalObject(data: any): data is ExternalObject;

package/typings/prepareGatewayDocument.d.cts

@@ -0,0 +1,2 @@
+import { DocumentNode, GraphQLSchema, GraphQLOutputType } from 'graphql';
+export declare function prepareGatewayDocument(originalDocument: DocumentNode, transformedSchema: GraphQLSchema, returnType: GraphQLOutputType, infoSchema?: GraphQLSchema): DocumentNode;

package/typings/prepareGatewayDocument.d.ts

@@ -1,2 +1,2 @@
-import { DocumentNode, GraphQLSchema, GraphQLOutputType } from '@graphql-tools/graphql';
+import { DocumentNode, GraphQLSchema, GraphQLOutputType } from 'graphql';
 export declare function prepareGatewayDocument(originalDocument: DocumentNode, transformedSchema: GraphQLSchema, returnType: GraphQLOutputType, infoSchema?: GraphQLSchema): DocumentNode;

package/typings/resolveExternalValue.d.cts

@@ -0,0 +1,3 @@
+import { GraphQLResolveInfo, GraphQLError, GraphQLSchema, GraphQLOutputType } from 'graphql';
+import { SubschemaConfig } from './types.js';
+export declare function resolveExternalValue<TContext extends Record<string, any>>(result: any, unpathedErrors: Array<GraphQLError>, subschema: GraphQLSchema | SubschemaConfig<any, any, any, TContext>, context?: Record<string, any>, info?: GraphQLResolveInfo, returnType?: GraphQLOutputType, skipTypeMerging?: boolean): any;

package/typings/resolveExternalValue.d.ts

@@ -1,3 +1,3 @@
-import { GraphQLResolveInfo, GraphQLError, GraphQLSchema, GraphQLOutputType } from '@graphql-tools/graphql';
+import { GraphQLResolveInfo, GraphQLError, GraphQLSchema, GraphQLOutputType } from 'graphql';
 import { SubschemaConfig } from './types.js';
 export declare function resolveExternalValue<TContext extends Record<string, any>>(result: any, unpathedErrors: Array<GraphQLError>, subschema: GraphQLSchema | SubschemaConfig<any, any, any, TContext>, context?: Record<string, any>, info?: GraphQLResolveInfo, returnType?: GraphQLOutputType, skipTypeMerging?: boolean): any;

package/typings/subschemaConfig.d.cts

@@ -0,0 +1,3 @@
+import { SubschemaConfig } from './types.js';
+export declare function isSubschemaConfig(value: any): value is SubschemaConfig<any, any, any, any>;
+export declare function cloneSubschemaConfig(subschemaConfig: SubschemaConfig): SubschemaConfig;

package/typings/symbols.d.cts

@@ -0,0 +1,3 @@
+export declare const UNPATHED_ERRORS_SYMBOL: unique symbol;
+export declare const OBJECT_SUBSCHEMA_SYMBOL: unique symbol;
+export declare const FIELD_SUBSCHEMA_MAP_SYMBOL: unique symbol;

package/typings/types.d.cts

@@ -0,0 +1,139 @@
+import { GraphQLSchema, GraphQLOutputType, SelectionSetNode, FieldNode, GraphQLResolveInfo, GraphQLFieldResolver, FragmentDefinitionNode, GraphQLObjectType, VariableDefinitionNode, OperationTypeNode, GraphQLError, GraphQLNamedType } from 'graphql';
+import DataLoader from 'dataloader';
+import { ExecutionRequest, ExecutionResult, Executor } from '@graphql-tools/utils';
+import { Subschema } from './Subschema.js';
+import { OBJECT_SUBSCHEMA_SYMBOL, FIELD_SUBSCHEMA_MAP_SYMBOL, UNPATHED_ERRORS_SYMBOL } from './symbols.js';
+export declare type SchemaTransform<TContext = Record<any, string>> = (originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig<any, any, any, TContext>, transformedSchema?: GraphQLSchema) => GraphQLSchema;
+export declare type RequestTransform<T = Record<string, any>, TContext = Record<any, string>> = (originalRequest: ExecutionRequest, delegationContext: DelegationContext<TContext>, transformationContext: T) => ExecutionRequest;
+export declare type ResultTransform<T = Record<string, any>, TContext = Record<any, string>> = (originalResult: ExecutionResult, delegationContext: DelegationContext<TContext>, transformationContext: T) => ExecutionResult;
+export interface Transform<T = any, TContext = Record<string, any>> {
+    transformSchema?: SchemaTransform<TContext>;
+    transformRequest?: RequestTransform<T, TContext>;
+    transformResult?: ResultTransform<T, TContext>;
+}
+export interface DelegationContext<TContext = Record<string, any>> {
+    subschema: GraphQLSchema | SubschemaConfig<any, any, any, TContext>;
+    subschemaConfig?: SubschemaConfig<any, any, any, TContext>;
+    targetSchema: GraphQLSchema;
+    operation: OperationTypeNode;
+    fieldName: string;
+    args?: Record<string, any>;
+    context?: TContext;
+    info?: GraphQLResolveInfo;
+    returnType: GraphQLOutputType;
+    onLocatedError?: (originalError: GraphQLError) => GraphQLError;
+    rootValue?: any;
+    transforms: Array<Transform<any, TContext>>;
+    transformedSchema: GraphQLSchema;
+    skipTypeMerging: boolean;
+}
+export interface IDelegateToSchemaOptions<TContext = Record<string, any>, TArgs = Record<string, any>> {
+    schema: GraphQLSchema | SubschemaConfig<any, any, any, TContext>;
+    operationName?: string;
+    operation?: OperationTypeNode;
+    fieldName?: string;
+    returnType?: GraphQLOutputType;
+    onLocatedError?: (originalError: GraphQLError) => GraphQLError;
+    args?: TArgs;
+    selectionSet?: SelectionSetNode;
+    fieldNodes?: ReadonlyArray<FieldNode>;
+    context?: TContext;
+    info: GraphQLResolveInfo;
+    rootValue?: any;
+    transforms?: Array<Transform<any, TContext>>;
+    transformedSchema?: GraphQLSchema;
+    validateRequest?: boolean;
+    skipTypeMerging?: boolean;
+}
+export interface IDelegateRequestOptions<TContext = Record<string, any>, TArgs = Record<string, any>> extends IDelegateToSchemaOptions<TContext, TArgs> {
+    request: ExecutionRequest;
+}
+export interface ICreateRequest {
+    sourceSchema?: GraphQLSchema;
+    sourceParentType?: GraphQLObjectType;
+    sourceFieldName?: string;
+    fragments?: Record<string, FragmentDefinitionNode>;
+    variableDefinitions?: ReadonlyArray<VariableDefinitionNode>;
+    variableValues?: Record<string, any>;
+    targetOperation: OperationTypeNode;
+    targetRootValue?: any;
+    targetOperationName?: string;
+    targetFieldName: string;
+    selectionSet?: SelectionSetNode;
+    fieldNodes?: ReadonlyArray<FieldNode>;
+    context?: any;
+    info?: GraphQLResolveInfo;
+}
+export declare type DelegationPlanBuilder = (schema: GraphQLSchema, sourceSubschema: Subschema<any, any, any, any>, variableValues: Record<string, any>, fragments: Record<string, FragmentDefinitionNode>, fieldNodes: FieldNode[]) => Array<Map<Subschema, SelectionSetNode>>;
+export interface MergedTypeInfo<TContext = Record<string, any>> {
+    typeName: string;
+    selectionSet?: SelectionSetNode;
+    targetSubschemas: Map<Subschema<any, any, any, TContext>, Array<Subschema<any, any, any, TContext>>>;
+    uniqueFields: Record<string, Subschema<any, any, any, TContext>>;
+    nonUniqueFields: Record<string, Array<Subschema<any, any, any, TContext>>>;
+    typeMaps: Map<GraphQLSchema | SubschemaConfig<any, any, any, TContext>, Record<string, GraphQLNamedType>>;
+    selectionSets: Map<Subschema<any, any, any, TContext>, SelectionSetNode>;
+    fieldSelectionSets: Map<Subschema<any, any, any, TContext>, Record<string, SelectionSetNode>>;
+    resolvers: Map<Subschema<any, any, any, TContext>, MergedTypeResolver<TContext>>;
+    delegationPlanBuilder: DelegationPlanBuilder;
+}
+export interface ICreateProxyingResolverOptions<TContext = Record<string, any>> {
+    subschemaConfig: SubschemaConfig<any, any, any, TContext>;
+    transformedSchema?: GraphQLSchema;
+    operation?: OperationTypeNode;
+    fieldName?: string;
+}
+export declare type CreateProxyingResolverFn<TContext = Record<string, any>> = (options: ICreateProxyingResolverOptions<TContext>) => GraphQLFieldResolver<any, TContext>;
+export interface BatchingOptions<K = any, V = any, C = K> {
+    extensionsReducer?: (mergedExtensions: Record<string, any>, request: ExecutionRequest) => Record<string, any>;
+    dataLoaderOptions?: DataLoader.Options<K, V, C>;
+}
+export interface SubschemaConfig<K = any, V = any, C = K, TContext = Record<string, any>> {
+    schema: GraphQLSchema;
+    createProxyingResolver?: CreateProxyingResolverFn<TContext>;
+    rootValue?: any;
+    transforms?: Array<Transform<any, TContext>>;
+    merge?: Record<string, MergedTypeConfig<any, any, TContext>>;
+    executor?: Executor<TContext>;
+    batch?: boolean;
+    batchingOptions?: BatchingOptions<K, V, C>;
+}
+export interface MergedTypeConfig<K = any, V = any, TContext = Record<string, any>> extends MergedTypeEntryPoint<K, V, TContext> {
+    entryPoints?: Array<MergedTypeEntryPoint>;
+    fields?: Record<string, MergedFieldConfig>;
+    computedFields?: Record<string, {
+        selectionSet?: string;
+    }>;
+    canonical?: boolean;
+}
+export interface MergedTypeEntryPoint<K = any, V = any, TContext = Record<string, any>> extends MergedTypeResolverOptions<K, V> {
+    selectionSet?: string;
+    key?: (originalResult: any) => K | PromiseLike<K>;
+    resolve?: MergedTypeResolver<TContext>;
+}
+export interface MergedTypeResolverOptions<K = any, V = any> {
+    fieldName?: string;
+    args?: (originalResult: any) => Record<string, any>;
+    argsFromKeys?: (keys: ReadonlyArray<K>) => Record<string, any>;
+    valuesFromResults?: (results: any, keys: ReadonlyArray<K>) => Array<V>;
+}
+export interface MergedFieldConfig {
+    selectionSet?: string;
+    computed?: boolean;
+    canonical?: boolean;
+}
+export declare type MergedTypeResolver<TContext = Record<string, any>> = (originalResult: any, context: TContext, info: GraphQLResolveInfo, subschema: Subschema<any, any, any, TContext>, selectionSet: SelectionSetNode, key: any | undefined, type: GraphQLOutputType) => any;
+export interface StitchingInfo<TContext = Record<string, any>> {
+    subschemaMap: Map<GraphQLSchema | SubschemaConfig<any, any, any, TContext>, Subschema<any, any, any, TContext>>;
+    fieldNodesByType: Record<string, Array<FieldNode>>;
+    fieldNodesByField: Record<string, Record<string, Array<FieldNode>>>;
+    dynamicSelectionSetsByField: Record<string, Record<string, Array<(node: FieldNode) => SelectionSetNode>>>;
+    mergedTypes: Record<string, MergedTypeInfo<TContext>>;
+}
+export interface ExternalObject<TContext = Record<string, any>> {
+    __typename: string;
+    key: any;
+    [OBJECT_SUBSCHEMA_SYMBOL]: GraphQLSchema | SubschemaConfig<any, any, any, TContext>;
+    [FIELD_SUBSCHEMA_MAP_SYMBOL]: Record<string, GraphQLSchema | SubschemaConfig<any, any, any, TContext>>;
+    [UNPATHED_ERRORS_SYMBOL]: Array<GraphQLError>;
+}

package/typings/types.d.ts

@@ -1,4 +1,4 @@
-import { GraphQLSchema, GraphQLOutputType, SelectionSetNode, FieldNode, GraphQLResolveInfo, GraphQLFieldResolver, FragmentDefinitionNode, GraphQLObjectType, VariableDefinitionNode, OperationTypeNode, GraphQLError, GraphQLNamedType } from '@graphql-tools/graphql';
+import { GraphQLSchema, GraphQLOutputType, SelectionSetNode, FieldNode, GraphQLResolveInfo, GraphQLFieldResolver, FragmentDefinitionNode, GraphQLObjectType, VariableDefinitionNode, OperationTypeNode, GraphQLError, GraphQLNamedType } from 'graphql';
 import DataLoader from 'dataloader';
 import { ExecutionRequest, ExecutionResult, Executor } from '@graphql-tools/utils';
 import { Subschema } from './Subschema.js';