@graphql-tools/delegate 9.0.0-alpha-e2ab84c8.0 → 9.0.0-alpha-25204a2f.0

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

@@ -1,11 +1,9 @@
 import { GraphQLResolveInfo } from 'graphql';
-import { ExternalObject } from './types';
+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/scalar conversion
- * d) handle type merging
- * e) handle deferred values
+ * 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/delegateToSchema.d.ts

@@ -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/finalizeGatewayRequest.d.ts

@@ -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/index.d.ts

@@ -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.ts

@@ -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/resolveExternalValue.d.ts

@@ -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/{subschemaConfig.d.ts → typings/subschemaConfig.d.ts}

@@ -1,3 +1,3 @@
-import { SubschemaConfig } from './types';
+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.ts

@@ -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/{types.d.ts → typings/types.d.ts}

@@ -1,15 +1,15 @@
-import { GraphQLSchema, GraphQLOutputType, SelectionSetNode, FieldNode, GraphQLResolveInfo, GraphQLFieldResolver, FragmentDefinitionNode, GraphQLObjectType, VariableDefinitionNode, OperationTypeNode, GraphQLError, GraphQLNamedType, GraphQLFieldMap } from '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';
-import { INFO_SYMBOL, INITIAL_PATH_SYMBOL, INITIAL_POSSIBLE_FIELDS, OBJECT_SUBSCHEMA_SYMBOL, RESPONSE_KEY_SUBSCHEMA_MAP_SYMBOL, UNPATHED_ERRORS_SYMBOL } from './symbols';
-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>> = (originalRequest: ExecutionRequest, delegationContext: DelegationContext, transformationContext: T) => ExecutionRequest;
-export declare type ResultTransform<T = Record<string, any>> = (originalResult: ExecutionResult, delegationContext: DelegationContext, transformationContext: T) => ExecutionResult;
+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>) => 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>;
-    transformResult?: ResultTransform<T>;
+    transformRequest?: RequestTransform<T, TContext>;
+    transformResult?: ResultTransform<T, TContext>;
 }
 export interface DelegationContext<TContext = Record<string, any>> {
     subschema: GraphQLSchema | SubschemaConfig<any, any, any, TContext>;
@@ -21,9 +21,11 @@ export interface DelegationContext<TContext = 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>;
@@ -41,20 +43,11 @@ export interface IDelegateToSchemaOptions<TContext = Record<string, any>, TArgs
     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 ICreateRequestFromInfo {
-    info: GraphQLResolveInfo;
-    rootValue?: any;
-    operationName?: string;
-    operation?: OperationTypeNode;
-    fieldName?: string;
-    selectionSet?: SelectionSetNode;
-    fieldNodes?: ReadonlyArray<FieldNode>;
-    context?: any;
-}
 export interface ICreateRequest {
     sourceSchema?: GraphQLSchema;
     sourceParentType?: GraphQLObjectType;
@@ -71,15 +64,7 @@ export interface ICreateRequest {
     context?: any;
     info?: GraphQLResolveInfo;
 }
-export interface ExternalValueFromResultOptions<TContext = Record<string, any>> {
-    result: ExecutionResult;
-    schema: GraphQLSchema | SubschemaConfig<any, any, any, TContext>;
-    fieldName?: string;
-    context?: TContext;
-    info?: GraphQLResolveInfo;
-    returnType?: GraphQLOutputType;
-    onLocatedError?: (error: GraphQLError) => GraphQLError;
-}
+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;
@@ -87,14 +72,13 @@ export interface MergedTypeInfo<TContext = Record<string, any>> {
     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>>;
-    subschemaFields: Record<string, boolean>;
     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;
 }
@@ -108,12 +92,12 @@ export interface SubschemaConfig<K = any, V = any, C = K, TContext = Record<stri
     createProxyingResolver?: CreateProxyingResolverFn<TContext>;
     rootValue?: any;
     transforms?: Array<Transform<any, TContext>>;
-    merge?: Record<string, MergedTypeConfig<any, TContext>>;
+    merge?: Record<string, MergedTypeConfig<any, any, TContext>>;
     executor?: Executor<TContext>;
     batch?: boolean;
     batchingOptions?: BatchingOptions<K, V, C>;
 }
-export interface MergedTypeConfig<K = any, TContext = Record<string, any>> extends MergedTypeEntryPoint<K, TContext> {
+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, {
@@ -121,22 +105,23 @@ export interface MergedTypeConfig<K = any, TContext = Record<string, any>> exten
     }>;
     canonical?: boolean;
 }
-export interface MergedTypeEntryPoint<K = any, TContext = Record<string, any>> extends MergedTypeResolverOptions<K> {
+export interface MergedTypeEntryPoint<K = any, V = any, TContext = Record<string, any>> extends MergedTypeResolverOptions<K, V> {
     selectionSet?: string;
-    key?: (originalResult: any) => K;
+    key?: (originalResult: any) => K | PromiseLike<K>;
     resolve?: MergedTypeResolver<TContext>;
 }
-export interface MergedTypeResolverOptions<K = any> {
+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: GraphQLSchema | SubschemaConfig<any, any, any, TContext>, selectionSet: SelectionSetNode, key?: any) => any;
+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>>;
@@ -147,11 +132,7 @@ export interface StitchingInfo<TContext = Record<string, any>> {
 export interface ExternalObject<TContext = Record<string, any>> {
     __typename: string;
     key: any;
-    [UNPATHED_ERRORS_SYMBOL]: Array<GraphQLError>;
-    [INITIAL_PATH_SYMBOL]: Array<string | number>;
     [OBJECT_SUBSCHEMA_SYMBOL]: GraphQLSchema | SubschemaConfig<any, any, any, TContext>;
-    [INITIAL_POSSIBLE_FIELDS]: GraphQLFieldMap<any, any>;
-    [INFO_SYMBOL]: GraphQLResolveInfo;
-    [RESPONSE_KEY_SUBSCHEMA_MAP_SYMBOL]: Record<string, GraphQLSchema | SubschemaConfig<any, any, any, TContext>>;
+    [FIELD_SUBSCHEMA_MAP_SYMBOL]: Record<string, GraphQLSchema | SubschemaConfig<any, any, any, TContext>>;
     [UNPATHED_ERRORS_SYMBOL]: Array<GraphQLError>;
 }

package/delegateToSchema.d.ts

@@ -1,9 +0,0 @@
-import { GraphQLSchema, DocumentNode } from 'graphql';
-import { Executor } from '@graphql-tools/utils';
-import { IDelegateToSchemaOptions, IDelegateRequestOptions, DelegationContext } from './types';
-export declare function delegateToSchema<TContext = Record<string, any>, TArgs = any>(options: IDelegateToSchemaOptions<TContext, TArgs>): any;
-export declare function delegateRequest<TContext = Record<string, any>, TArgs = any>(options: IDelegateRequestOptions<TContext, TArgs>): any;
-export declare function getDelegationContext<TContext>({ request, schema, fieldName, returnType, args, info, transforms, transformedSchema, }: IDelegateRequestOptions<TContext>): DelegationContext<TContext>;
-export declare function validateRequest(delegationContext: DelegationContext<any>, document: DocumentNode): void;
-export declare function getExecutor<TContext>(delegationContext: DelegationContext<TContext>): Executor<TContext>;
-export declare const createDefaultExecutor: (schema: GraphQLSchema) => Executor;

package/externalObjects.d.ts

@@ -1,11 +0,0 @@
-import { GraphQLError, GraphQLFieldMap, GraphQLResolveInfo, GraphQLSchema } from 'graphql';
-import { ExternalObject, SubschemaConfig } from './types';
-export declare function isExternalObject(data: any): data is ExternalObject;
-export declare function annotateExternalObject<TContext = Record<string, any>>(object: any, errors: Array<GraphQLError>, initialPath: Array<string | number>, subschema: GraphQLSchema | SubschemaConfig<any, any, any, TContext>, info?: GraphQLResolveInfo): ExternalObject;
-export declare function getInitialPath(object: ExternalObject): Array<string | number>;
-export declare function getInitialPossibleFields(object: ExternalObject): GraphQLFieldMap<any, any>;
-export declare function getInfo(object: ExternalObject): GraphQLResolveInfo;
-export declare function getUnpathedErrors(object: ExternalObject): Array<GraphQLError>;
-export declare function getObjectSubchema(object: ExternalObject): GraphQLSchema | SubschemaConfig;
-export declare function getSubschemaMap(object: ExternalObject): Record<string, GraphQLSchema | SubschemaConfig>;
-export declare function getSubschema(object: ExternalObject, responseKey: string): GraphQLSchema | SubschemaConfig;

package/externalValues.d.ts

@@ -1,4 +0,0 @@
-import { GraphQLResolveInfo, GraphQLError, GraphQLSchema, GraphQLOutputType } from 'graphql';
-import { ExternalValueFromResultOptions, SubschemaConfig } from './types';
-export declare function externalValueFromResult<TContext = Record<string, any>>({ result, schema, info, context, fieldName, returnType, onLocatedError, }: ExternalValueFromResultOptions<TContext>): any;
-export declare function createExternalValue<TContext = Record<string, any>>(data: any, unpathedErrors: Array<GraphQLError>, initialPath: Array<string | number>, subschema: GraphQLSchema | SubschemaConfig<any, any, any, TContext>, context?: TContext, info?: GraphQLResolveInfo, returnType?: GraphQLOutputType): any;

package/finalizeGatewayRequest.d.ts

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

package/getMergedParent.d.ts

@@ -1,9 +0,0 @@
-import { FieldNode, GraphQLResolveInfo, GraphQLSchema } from 'graphql';
-import { ExternalObject, MergedTypeInfo } from './types';
-import { Subschema } from './Subschema';
-export declare function getMergedParent(parent: ExternalObject, context: Record<string, any>, info: GraphQLResolveInfo): Promise<ExternalObject>;
-export declare const buildDelegationPlan: (mergedTypeInfo: MergedTypeInfo, gatewaySchema: GraphQLSchema, sourceSubschema: Subschema, ...fieldNodeArrays: Array<ReadonlyArray<FieldNode>>) => {
-    requiredKeys: Record<string, Set<string>>;
-    delegationMaps: Array<Map<Subschema, Array<FieldNode>>>;
-    stageMap: Record<string, number>;
-};

package/index.d.ts

@@ -1,11 +0,0 @@
-export * from './Subschema';
-export * from './Transformer';
-export * from './applySchemaTransforms';
-export * from './createRequest';
-export * from './defaultMergedResolver';
-export * from './delegateToSchema';
-export * from './getMergedParent';
-export * from './externalObjects';
-export * from './externalValues';
-export * from './subschemaConfig';
-export * from './types';