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

package/typings/transforms/TransformInterfaceFields.d.ts

@@ -0,0 +1,17 @@
+import { GraphQLSchema } from 'graphql';
+import { ExecutionRequest, ExecutionResult } from '@graphql-tools/utils';
+import { Transform, DelegationContext, SubschemaConfig } from '@graphql-tools/delegate';
+import { FieldTransformer, FieldNodeTransformer } from '../types.js';
+interface TransformInterfaceFieldsTransformationContext extends Record<string, any> {
+}
+export default class TransformInterfaceFields<TContext = Record<string, any>> implements Transform<TransformInterfaceFieldsTransformationContext, TContext> {
+    private readonly interfaceFieldTransformer;
+    private readonly fieldNodeTransformer;
+    private transformer;
+    constructor(interfaceFieldTransformer: FieldTransformer<TContext>, fieldNodeTransformer?: FieldNodeTransformer);
+    private _getTransformer;
+    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig<any, any, any, TContext>): GraphQLSchema;
+    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext<TContext>, transformationContext: TransformInterfaceFieldsTransformationContext): ExecutionRequest;
+    transformResult(originalResult: ExecutionResult, delegationContext: DelegationContext<TContext>, transformationContext: TransformInterfaceFieldsTransformationContext): ExecutionResult;
+}
+export {};

package/typings/transforms/TransformObjectFields.d.ts

@@ -0,0 +1,17 @@
+import { GraphQLSchema } from 'graphql';
+import { ExecutionRequest, ExecutionResult } from '@graphql-tools/utils';
+import { Transform, DelegationContext, SubschemaConfig } from '@graphql-tools/delegate';
+import { FieldTransformer, FieldNodeTransformer } from '../types.js';
+interface TransformObjectFieldsTransformationContext extends Record<string, any> {
+}
+export default class TransformObjectFields<TContext = Record<string, any>> implements Transform<TransformObjectFieldsTransformationContext, TContext> {
+    private readonly objectFieldTransformer;
+    private readonly fieldNodeTransformer;
+    private transformer;
+    constructor(objectFieldTransformer: FieldTransformer<TContext>, fieldNodeTransformer?: FieldNodeTransformer);
+    private _getTransformer;
+    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig<any, any, any, TContext>): GraphQLSchema;
+    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext<TContext>, transformationContext: TransformObjectFieldsTransformationContext): ExecutionRequest;
+    transformResult(originalResult: ExecutionResult, delegationContext: DelegationContext<TContext>, transformationContext: TransformObjectFieldsTransformationContext): ExecutionResult;
+}
+export {};

package/{transforms → typings/transforms}/TransformQuery.d.ts

@@ -1,10 +1,12 @@
 import { SelectionSetNode, FragmentDefinitionNode } from 'graphql';
 import { ExecutionRequest, ExecutionResult } from '@graphql-tools/utils';
 import { Transform, DelegationContext } from '@graphql-tools/delegate';
-export declare type QueryTransformer = (selectionSet: SelectionSetNode, fragments: Record<string, FragmentDefinitionNode>, delegationContext: DelegationContext, transformationContext: Record<string, any>) => SelectionSetNode;
-export declare type ResultTransformer = (result: any, delegationContext: DelegationContext, transformationContext: Record<string, any>) => any;
+export declare type QueryTransformer = <TContext>(selectionSet: SelectionSetNode | undefined, fragments: Record<string, FragmentDefinitionNode>, delegationContext: DelegationContext<TContext>, transformationContext: Record<string, any>) => SelectionSetNode;
+export declare type ResultTransformer = <TContext>(result: any, delegationContext: DelegationContext<TContext>, transformationContext: Record<string, any>) => any;
 export declare type ErrorPathTransformer = (path: ReadonlyArray<string | number>) => Array<string | number>;
-export default class TransformQuery implements Transform {
+interface TransformQueryTransformationContext extends Record<string, any> {
+}
+export default class TransformQuery<TContext = Record<string, any>> implements Transform<TransformQueryTransformationContext, TContext> {
     private readonly path;
     private readonly queryTransformer;
     private readonly resultTransformer;
@@ -17,8 +19,9 @@ export default class TransformQuery implements Transform {
         errorPathTransformer?: ErrorPathTransformer;
         fragments?: Record<string, FragmentDefinitionNode>;
     });
-    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext, transformationContext: Record<string, any>): ExecutionRequest;
-    transformResult(originalResult: ExecutionResult, delegationContext: DelegationContext, transformationContext: Record<string, any>): ExecutionResult;
+    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext<TContext>, transformationContext: TransformQueryTransformationContext): ExecutionRequest;
+    transformResult(originalResult: ExecutionResult, delegationContext: DelegationContext<TContext>, transformationContext: TransformQueryTransformationContext): ExecutionResult;
     private transformData;
     private transformErrors;
 }
+export {};

package/typings/transforms/TransformRootFields.d.ts

@@ -0,0 +1,17 @@
+import { GraphQLSchema } from 'graphql';
+import { ExecutionRequest, ExecutionResult } from '@graphql-tools/utils';
+import { Transform, DelegationContext, SubschemaConfig } from '@graphql-tools/delegate';
+import { RootFieldTransformer, FieldNodeTransformer } from '../types.js';
+interface TransformRootFieldsTransformationContext extends Record<string, any> {
+}
+export default class TransformRootFields<TContext = Record<string, any>> implements Transform<TransformRootFieldsTransformationContext, TContext> {
+    private readonly rootFieldTransformer;
+    private readonly fieldNodeTransformer;
+    private transformer;
+    constructor(rootFieldTransformer: RootFieldTransformer<TContext>, fieldNodeTransformer?: FieldNodeTransformer);
+    private _getTransformer;
+    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig<any, any, any, TContext>): GraphQLSchema;
+    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext<TContext>, transformationContext: TransformRootFieldsTransformationContext): ExecutionRequest;
+    transformResult(originalResult: ExecutionResult, delegationContext: DelegationContext<TContext>, transformationContext: TransformRootFieldsTransformationContext): ExecutionResult;
+}
+export {};

package/{transforms → typings/transforms}/WrapFields.d.ts

@@ -8,7 +8,7 @@ interface WrapFieldsTransformationContext {
         alias: string;
     }>;
 }
-export default class WrapFields<TContext> implements Transform<WrapFieldsTransformationContext, TContext> {
+export default class WrapFields<TContext extends Record<string, any>> implements Transform<WrapFieldsTransformationContext, TContext> {
     private readonly outerTypeName;
     private readonly wrappingFieldNames;
     private readonly wrappingTypeNames;
@@ -16,9 +16,9 @@ export default class WrapFields<TContext> implements Transform<WrapFieldsTransfo
     private readonly fieldNames;
     private readonly transformer;
     constructor(outerTypeName: string, wrappingFieldNames: Array<string>, wrappingTypeNames: Array<string>, fieldNames?: Array<string>, prefix?: string);
-    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig<any, any, any, TContext>, transformedSchema?: GraphQLSchema): GraphQLSchema;
-    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext, transformationContext: WrapFieldsTransformationContext): ExecutionRequest;
-    transformResult(originalResult: ExecutionResult, delegationContext: DelegationContext, transformationContext: WrapFieldsTransformationContext): ExecutionResult;
+    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig<any, any, any, TContext>): GraphQLSchema;
+    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext<TContext>, transformationContext: WrapFieldsTransformationContext): ExecutionRequest;
+    transformResult(originalResult: ExecutionResult, delegationContext: DelegationContext<TContext>, transformationContext: WrapFieldsTransformationContext): ExecutionResult;
 }
 export declare function dehoistValue(originalValue: any, context: WrapFieldsTransformationContext): any;
 export {};

package/{transforms → typings/transforms}/WrapQuery.d.ts

@@ -2,11 +2,14 @@ import { SelectionNode, SelectionSetNode } from 'graphql';
 import { ExecutionRequest, ExecutionResult } from '@graphql-tools/utils';
 import { Transform, DelegationContext } from '@graphql-tools/delegate';
 export declare type QueryWrapper = (subtree: SelectionSetNode) => SelectionNode | SelectionSetNode;
-export default class WrapQuery implements Transform {
+interface WrapQueryTransformationContext extends Record<string, any> {
+}
+export default class WrapQuery<TContext = Record<string, any>> implements Transform<WrapQueryTransformationContext, TContext> {
     private readonly wrapper;
     private readonly extractor;
     private readonly path;
     constructor(path: Array<string>, wrapper: QueryWrapper, extractor: (result: any) => any);
-    transformRequest(originalRequest: ExecutionRequest, _delegationContext: DelegationContext, _transformationContext: Record<string, any>): ExecutionRequest;
-    transformResult(originalResult: ExecutionResult, _delegationContext: DelegationContext, _transformationContext: Record<string, any>): ExecutionResult;
+    transformRequest(originalRequest: ExecutionRequest, _delegationContext: DelegationContext<TContext>, _transformationContext: WrapQueryTransformationContext): ExecutionRequest;
+    transformResult(originalResult: ExecutionResult, _delegationContext: DelegationContext<TContext>, _transformationContext: WrapQueryTransformationContext): ExecutionResult;
 }
+export {};

package/typings/transforms/WrapType.d.ts

@@ -0,0 +1,13 @@
+import { GraphQLSchema } from 'graphql';
+import { ExecutionRequest, ExecutionResult } from '@graphql-tools/utils';
+import { Transform, DelegationContext, SubschemaConfig } from '@graphql-tools/delegate';
+interface WrapTypeTransformationContext extends Record<string, any> {
+}
+export default class WrapType<TContext extends Record<string, any> = Record<string, any>> implements Transform<WrapTypeTransformationContext, TContext> {
+    private readonly transformer;
+    constructor(outerTypeName: string, innerTypeName: string, fieldName: string);
+    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig<any, any, any, TContext>): GraphQLSchema;
+    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext<TContext>, transformationContext: WrapTypeTransformationContext): ExecutionRequest;
+    transformResult(originalResult: ExecutionResult, delegationContext: DelegationContext<TContext>, transformationContext: WrapTypeTransformationContext): ExecutionResult;
+}
+export {};

package/typings/transforms/index.d.ts

@@ -0,0 +1,32 @@
+export { default as RenameTypes } from './RenameTypes.js';
+export { default as FilterTypes } from './FilterTypes.js';
+export { default as RenameRootTypes } from './RenameRootTypes.js';
+export { default as TransformCompositeFields } from './TransformCompositeFields.js';
+export { default as TransformRootFields } from './TransformRootFields.js';
+export { default as RenameRootFields } from './RenameRootFields.js';
+export { default as FilterRootFields } from './FilterRootFields.js';
+export { default as TransformObjectFields } from './TransformObjectFields.js';
+export { default as RenameObjectFields } from './RenameObjectFields.js';
+export { default as RenameObjectFieldArguments } from './RenameObjectFieldArguments.js';
+export { default as FilterObjectFields } from './FilterObjectFields.js';
+export { default as TransformInterfaceFields } from './TransformInterfaceFields.js';
+export { default as RenameInterfaceFields } from './RenameInterfaceFields.js';
+export { default as FilterInterfaceFields } from './FilterInterfaceFields.js';
+export { default as TransformInputObjectFields } from './TransformInputObjectFields.js';
+export { default as RenameInputObjectFields } from './RenameInputObjectFields.js';
+export { default as FilterInputObjectFields } from './FilterInputObjectFields.js';
+export { default as MapLeafValues } from './MapLeafValues.js';
+export { default as TransformEnumValues } from './TransformEnumValues.js';
+export { default as TransformQuery } from './TransformQuery.js';
+export { default as FilterObjectFieldDirectives } from './FilterObjectFieldDirectives.js';
+export { default as RemoveObjectFieldDirectives } from './RemoveObjectFieldDirectives.js';
+export { default as RemoveObjectFieldsWithDirective } from './RemoveObjectFieldsWithDirective.js';
+export { default as RemoveObjectFieldDeprecations } from './RemoveObjectFieldDeprecations.js';
+export { default as RemoveObjectFieldsWithDeprecation } from './RemoveObjectFieldsWithDeprecation.js';
+export { default as PruneSchema } from './PruneSchema.js';
+export { default as WrapType } from './WrapType.js';
+export { default as WrapFields } from './WrapFields.js';
+export { default as HoistField } from './HoistField.js';
+export { default as MapFields } from './MapFields.js';
+export { default as WrapQuery } from './WrapQuery.js';
+export { default as ExtractField } from './ExtractField.js';

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

@@ -2,8 +2,8 @@ import { GraphQLInputFieldConfig, GraphQLFieldConfig, FieldNode, FragmentDefinit
 import { DelegationContext } from '@graphql-tools/delegate';
 import { ExecutionRequest, Maybe } from '@graphql-tools/utils';
 export declare type InputFieldTransformer = (typeName: string, fieldName: string, inputFieldConfig: GraphQLInputFieldConfig) => GraphQLInputFieldConfig | [string, GraphQLInputFieldConfig] | null | undefined;
-export declare type InputFieldNodeTransformer = (typeName: string, fieldName: string, inputFieldNode: ObjectFieldNode, request: ExecutionRequest, delegationContext?: DelegationContext) => ObjectFieldNode | Array<ObjectFieldNode>;
-export declare type InputObjectNodeTransformer = (typeName: string, inputObjectNode: ObjectValueNode, request: ExecutionRequest, delegationContext?: DelegationContext) => ObjectValueNode | undefined;
+export declare type InputFieldNodeTransformer = <TContext>(typeName: string, fieldName: string, inputFieldNode: ObjectFieldNode, request: ExecutionRequest, delegationContext?: DelegationContext<TContext>) => ObjectFieldNode | Array<ObjectFieldNode>;
+export declare type InputObjectNodeTransformer = <TContext>(typeName: string, inputObjectNode: ObjectValueNode, request: ExecutionRequest, delegationContext?: DelegationContext<TContext>) => ObjectValueNode | undefined;
 export declare type FieldTransformer<TContext = Record<string, any>> = (typeName: string, fieldName: string, fieldConfig: GraphQLFieldConfig<any, TContext>) => Maybe<GraphQLFieldConfig<any, TContext> | [string, GraphQLFieldConfig<any, TContext>]>;
 export declare type RootFieldTransformer<TContext = Record<string, any>> = (operation: 'Query' | 'Mutation' | 'Subscription', fieldName: string, fieldConfig: GraphQLFieldConfig<any, TContext>) => Maybe<GraphQLFieldConfig<any, TContext> | [string, GraphQLFieldConfig<any, TContext>]>;
 export declare type EnumValueTransformer = (typeName: string, externalValue: string, enumValueConfig: GraphQLEnumValueConfig) => Maybe<GraphQLEnumValueConfig | [string, GraphQLEnumValueConfig]>;

package/typings/wrapSchema.d.ts

@@ -0,0 +1,3 @@
+import { GraphQLSchema } from 'graphql';
+import { SubschemaConfig } from '@graphql-tools/delegate';
+export declare function wrapSchema<TConfig extends Record<string, any> = Record<string, any>>(subschemaConfig: SubschemaConfig<any, any, any, TConfig>): GraphQLSchema;

package/generateProxyingResolvers.d.ts

@@ -1,4 +0,0 @@
-import { GraphQLFieldResolver } from 'graphql';
-import { SubschemaConfig, ICreateProxyingResolverOptions } from '@graphql-tools/delegate';
-export declare function generateProxyingResolvers<TContext>(subschemaConfig: SubschemaConfig<any, any, any, TContext>): Record<string, Record<string, GraphQLFieldResolver<any, any>>>;
-export declare function defaultCreateProxyingResolver<TContext>({ subschemaConfig, operation, transformedSchema, }: ICreateProxyingResolverOptions<TContext>): GraphQLFieldResolver<any, any>;

package/index.d.ts

@@ -1,5 +0,0 @@
-export { wrapSchema } from './wrapSchema';
-export { defaultCreateProxyingResolver, generateProxyingResolvers } from './generateProxyingResolvers';
-export * from './transforms/index';
-export * from './types';
-export * from './introspect';