@graphql-tools/delegate 9.0.0-alpha-e309ae22.0 → 9.0.0-alpha-20220809152812-1a2a11ba

package/cjs/applySchemaTransforms.js

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.applySchemaTransforms = void 0;
-function applySchemaTransforms(originalWrappingSchema, subschemaConfig) {
+const utils_1 = require("@graphql-tools/utils");
+// TODO: Instead of memoization, we can make sure that this isn't called multiple times
+exports.applySchemaTransforms = (0, utils_1.memoize2)(function applySchemaTransforms(originalWrappingSchema, subschemaConfig) {
     const schemaTransforms = subschemaConfig.transforms;
     if (schemaTransforms == null) {
         return originalWrappingSchema;
     }
-    return schemaTransforms.reduce((schema, transform) => transform.transformSchema != null ? transform.transformSchema(schema, subschemaConfig) : schema, originalWrappingSchema);
-}
-exports.applySchemaTransforms = applySchemaTransforms;
+    return schemaTransforms.reduce((schema, transform) => { var _a; return ((_a = transform.transformSchema) === null || _a === void 0 ? void 0 : _a.call(transform, schema, subschemaConfig)) || schema; }, originalWrappingSchema);
+});

package/esm/applySchemaTransforms.js

@@ -1,7 +1,9 @@
-export function applySchemaTransforms(originalWrappingSchema, subschemaConfig) {
+import { memoize2 } from '@graphql-tools/utils';
+// TODO: Instead of memoization, we can make sure that this isn't called multiple times
+export const applySchemaTransforms = memoize2(function applySchemaTransforms(originalWrappingSchema, subschemaConfig) {
     const schemaTransforms = subschemaConfig.transforms;
     if (schemaTransforms == null) {
         return originalWrappingSchema;
     }
-    return schemaTransforms.reduce((schema, transform) => transform.transformSchema != null ? transform.transformSchema(schema, subschemaConfig) : schema, originalWrappingSchema);
-}
+    return schemaTransforms.reduce((schema, transform) => { var _a; return ((_a = transform.transformSchema) === null || _a === void 0 ? void 0 : _a.call(transform, schema, subschemaConfig)) || schema; }, originalWrappingSchema);
+});

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@graphql-tools/delegate",
-  "version": "9.0.0-alpha-e309ae22.0",
+  "version": "9.0.0-alpha-20220809152812-1a2a11ba",
   "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.0",
-    "@graphql-tools/schema": "8.5.0",
-    "@graphql-tools/utils": "8.8.0",
+    "@graphql-tools/batch-execute": "8.5.2-alpha-20220809152812-1a2a11ba",
+    "@graphql-tools/schema": "9.0.0-alpha-20220809152812-1a2a11ba",
+    "@graphql-tools/utils": "8.9.1-alpha-20220809152812-1a2a11ba",
     "dataloader": "2.1.0",
     "tslib": "~2.4.0",
     "value-or-promise": "1.0.11"
@@ -30,7 +30,7 @@
   "exports": {
     ".": {
       "require": {
-        "types": "./typings/index.d.ts",
+        "types": "./typings/index.d.cts",
         "default": "./cjs/index.js"
       },
       "import": {
@@ -44,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.cjs';
+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/Transformer.d.cts

@@ -0,0 +1,10 @@
+import { ExecutionRequest, ExecutionResult } from '@graphql-tools/utils';
+import { DelegationContext } from './types.cjs';
+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.cjs';
+export declare const applySchemaTransforms: (originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig<any, any, any, any>) => GraphQLSchema;

package/typings/applySchemaTransforms.d.ts

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

package/typings/checkResultAndHandleErrors.d.cts

@@ -0,0 +1,8 @@
+import { GraphQLError } from 'graphql';
+import { ExecutionResult } from '@graphql-tools/utils';
+import { DelegationContext } from './types.cjs';
+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/createRequest.d.cts

@@ -0,0 +1,5 @@
+import { GraphQLSchema, GraphQLObjectType, OperationTypeNode } from 'graphql';
+import { ExecutionRequest } from '@graphql-tools/utils';
+import { ICreateRequest } from './types.cjs';
+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/defaultMergedResolver.d.cts

@@ -0,0 +1,9 @@
+import { GraphQLResolveInfo } from 'graphql';
+import { ExternalObject } from './types.cjs';
+/**
+ * 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/delegateToSchema.d.cts

@@ -0,0 +1,6 @@
+import { GraphQLSchema } from 'graphql';
+import { Executor } from '@graphql-tools/utils';
+import { IDelegateToSchemaOptions, IDelegateRequestOptions } from './types.cjs';
+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.cts

@@ -0,0 +1,3 @@
+import { ExecutionRequest } from '@graphql-tools/utils';
+import { DelegationContext } from './types.cjs';
+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/index.d.cts

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

package/typings/mergeFields.d.cts

@@ -0,0 +1,8 @@
+import { GraphQLResolveInfo, GraphQLError, GraphQLSchema } from 'graphql';
+import { ExternalObject, MergedTypeInfo, SubschemaConfig } from './types.cjs';
+import { Subschema } from './Subschema.cjs';
+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/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/resolveExternalValue.d.cts

@@ -0,0 +1,3 @@
+import { GraphQLResolveInfo, GraphQLError, GraphQLSchema, GraphQLOutputType } from 'graphql';
+import { SubschemaConfig } from './types.cjs';
+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.cjs';
+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,135 @@
+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.cjs';
+import { OBJECT_SUBSCHEMA_SYMBOL, FIELD_SUBSCHEMA_MAP_SYMBOL, UNPATHED_ERRORS_SYMBOL } from './symbols.cjs';
+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, 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>;
+    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>;
+    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>;
+}