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

package/esm/wrapSchema.js

@@ -0,0 +1,53 @@
+import { GraphQLObjectType, GraphQLInterfaceType, GraphQLUnionType, } from 'graphql';
+import { MapperKind, mapSchema } from '@graphql-tools/utils';
+import { defaultMergedResolver, applySchemaTransforms } from '@graphql-tools/delegate';
+import { generateProxyingResolvers } from './generateProxyingResolvers.js';
+export function wrapSchema(subschemaConfig) {
+    const targetSchema = subschemaConfig.schema;
+    const proxyingResolvers = generateProxyingResolvers(subschemaConfig);
+    const schema = createWrappingSchema(targetSchema, proxyingResolvers);
+    return applySchemaTransforms(schema, subschemaConfig);
+}
+function createWrappingSchema(schema, proxyingResolvers) {
+    return mapSchema(schema, {
+        [MapperKind.ROOT_OBJECT]: type => {
+            var _a;
+            const config = type.toConfig();
+            const fieldConfigMap = config.fields;
+            for (const fieldName in fieldConfigMap) {
+                const field = fieldConfigMap[fieldName];
+                if (field == null) {
+                    continue;
+                }
+                fieldConfigMap[fieldName] = {
+                    ...field,
+                    ...(_a = proxyingResolvers[type.name]) === null || _a === void 0 ? void 0 : _a[fieldName],
+                };
+            }
+            return new GraphQLObjectType(config);
+        },
+        [MapperKind.OBJECT_TYPE]: type => {
+            const config = type.toConfig();
+            config.isTypeOf = undefined;
+            for (const fieldName in config.fields) {
+                const field = config.fields[fieldName];
+                if (field == null) {
+                    continue;
+                }
+                field.resolve = defaultMergedResolver;
+                field.subscribe = undefined;
+            }
+            return new GraphQLObjectType(config);
+        },
+        [MapperKind.INTERFACE_TYPE]: type => {
+            const config = type.toConfig();
+            delete config.resolveType;
+            return new GraphQLInterfaceType(config);
+        },
+        [MapperKind.UNION_TYPE]: type => {
+            const config = type.toConfig();
+            delete config.resolveType;
+            return new GraphQLUnionType(config);
+        },
+    });
+}

package/package.json

@@ -1,17 +1,17 @@
 {
   "name": "@graphql-tools/wrap",
-  "version": "9.0.0-alpha-e2ab84c8.0",
+  "version": "9.0.0-alpha-25204a2f.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"
+    "graphql": "^14.0.0 || ^15.0.0 || ^16.0.0 || ^17.0.0"
   },
   "dependencies": {
-    "@graphql-tools/delegate": "9.0.0-alpha-e2ab84c8.0",
-    "@graphql-tools/schema": "8.2.1-alpha-e2ab84c8.0",
-    "@graphql-tools/utils": "9.0.0-alpha-e2ab84c8.0",
-    "tslib": "~2.3.0",
-    "value-or-promise": "1.0.10"
+    "@graphql-tools/delegate": "9.0.0-alpha-25204a2f.0",
+    "@graphql-tools/schema": "8.5.0",
+    "@graphql-tools/utils": "8.8.0",
+    "tslib": "^2.4.0",
+    "value-or-promise": "1.0.11"
   },
   "repository": {
     "type": "git",
@@ -19,20 +19,42 @@
     "directory": "packages/wrap"
   },
   "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": {
+        "types": "./typings/index.d.ts",
+        "default": "./cjs/index.js"
+      },
+      "import": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      },
+      "default": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      }
     },
     "./*": {
-      "require": "./*.js",
-      "import": "./*.mjs"
-    }
+      "require": {
+        "types": "./typings/*.d.ts",
+        "default": "./cjs/*.js"
+      },
+      "import": {
+        "types": "./typings/*.d.ts",
+        "default": "./esm/*.js"
+      },
+      "default": {
+        "types": "./typings/*.d.ts",
+        "default": "./esm/*.js"
+      }
+    },
+    "./package.json": "./package.json"
   }
-}
+}

package/typings/generateProxyingResolvers.d.ts

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

package/typings/index.d.ts

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

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

@@ -1,11 +1,14 @@
 import { ExecutionRequest } from '@graphql-tools/utils';
 import { Transform, DelegationContext } from '@graphql-tools/delegate';
-export default class ExtractField implements Transform {
+interface ExtractFieldTransformationContext extends Record<string, any> {
+}
+export default class ExtractField<TContext = Record<string, any>> implements Transform<ExtractFieldTransformationContext, TContext> {
     private readonly from;
     private readonly to;
     constructor({ from, to }: {
         from: Array<string>;
         to: Array<string>;
     });
-    transformRequest(originalRequest: ExecutionRequest, _delegationContext: DelegationContext, _transformationContext: Record<string, any>): ExecutionRequest;
+    transformRequest(originalRequest: ExecutionRequest, _delegationContext: DelegationContext<TContext>, _transformationContext: ExtractFieldTransformationContext): ExecutionRequest;
 }
+export {};

package/typings/transforms/FilterInputObjectFields.d.ts

@@ -0,0 +1,13 @@
+import { GraphQLSchema } from 'graphql';
+import { ExecutionRequest, InputFieldFilter } from '@graphql-tools/utils';
+import { Transform, DelegationContext, SubschemaConfig } from '@graphql-tools/delegate';
+import { InputObjectNodeTransformer } from '../types.js';
+interface FilterInputObjectFieldsTransformationContext extends Record<string, any> {
+}
+export default class FilterInputObjectFields<TContext = Record<string, any>> implements Transform<FilterInputObjectFieldsTransformationContext, TContext> {
+    private readonly transformer;
+    constructor(filter: InputFieldFilter, inputObjectNodeTransformer?: InputObjectNodeTransformer);
+    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig<any, any, any, TContext>): GraphQLSchema;
+    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext<TContext>, transformationContext: FilterInputObjectFieldsTransformationContext): ExecutionRequest;
+}
+export {};

package/typings/transforms/FilterInterfaceFields.d.ts

@@ -0,0 +1,11 @@
+import { GraphQLSchema } from 'graphql';
+import { FieldFilter } from '@graphql-tools/utils';
+import { SubschemaConfig, Transform } from '@graphql-tools/delegate';
+interface FilterInterfaceFieldsTransformationContext extends Record<string, any> {
+}
+export default class FilterInterfaceFields<TContext = Record<string, any>> implements Transform<FilterInterfaceFieldsTransformationContext, TContext> {
+    private readonly transformer;
+    constructor(filter: FieldFilter);
+    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig<any, any, any, TContext>): GraphQLSchema;
+}
+export {};

package/typings/transforms/FilterObjectFieldDirectives.d.ts

@@ -0,0 +1,10 @@
+import { GraphQLSchema } from 'graphql';
+import { SubschemaConfig, Transform } from '@graphql-tools/delegate';
+interface FilterObjectFieldDirectivesTransformationContext extends Record<string, any> {
+}
+export default class FilterObjectFieldDirectives<TContext = Record<string, any>> implements Transform<FilterObjectFieldDirectivesTransformationContext, TContext> {
+    private readonly filter;
+    constructor(filter: (dirName: string, dirValue: any) => boolean);
+    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig<any, any, any, TContext>): GraphQLSchema;
+}
+export {};

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

@@ -1,8 +1,11 @@
 import { GraphQLSchema } from 'graphql';
 import { ObjectFieldFilter } from '@graphql-tools/utils';
 import { SubschemaConfig, Transform } from '@graphql-tools/delegate';
-export default class FilterObjectFields implements Transform {
+interface FilterObjectFieldsTransformationContext extends Record<string, any> {
+}
+export default class FilterObjectFields<TContext = Record<string, any>> implements Transform<FilterObjectFieldsTransformationContext, TContext> {
     private readonly transformer;
     constructor(filter: ObjectFieldFilter);
-    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig, transformedSchema?: GraphQLSchema): GraphQLSchema;
+    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig<any, any, any, TContext>): GraphQLSchema;
 }
+export {};

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

@@ -1,8 +1,11 @@
 import { GraphQLSchema } from 'graphql';
 import { RootFieldFilter } from '@graphql-tools/utils';
 import { SubschemaConfig, Transform } from '@graphql-tools/delegate';
-export default class FilterRootFields implements Transform {
+interface FilterRootFieldsTransformationContext extends Record<string, any> {
+}
+export default class FilterRootFields<TContext = Record<string, any>> implements Transform<FilterRootFieldsTransformationContext, TContext> {
     private readonly transformer;
     constructor(filter: RootFieldFilter);
-    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig, transformedSchema?: GraphQLSchema): GraphQLSchema;
+    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig<any, any, any, TContext>): GraphQLSchema;
 }
+export {};

package/typings/transforms/FilterTypes.d.ts

@@ -0,0 +1,10 @@
+import { GraphQLSchema, GraphQLNamedType } from 'graphql';
+import { SubschemaConfig, Transform } from '@graphql-tools/delegate';
+interface FilterTypesTransformationContext extends Record<string, any> {
+}
+export default class FilterTypes<TContext = Record<string, any>> implements Transform<FilterTypesTransformationContext, TContext> {
+    private readonly filter;
+    constructor(filter: (type: GraphQLNamedType) => boolean);
+    transformSchema(originalWrappingSchema: GraphQLSchema, _subschemaConfig: SubschemaConfig<any, any, any, TContext>): GraphQLSchema;
+}
+export {};

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

@@ -1,7 +1,9 @@
 import { GraphQLSchema, FieldNode, GraphQLArgument } from 'graphql';
 import { ExecutionRequest, ExecutionResult } from '@graphql-tools/utils';
 import { Transform, DelegationContext, SubschemaConfig } from '@graphql-tools/delegate';
-export default class HoistField implements Transform {
+interface HoistFieldTransformationContext extends Record<string, any> {
+}
+export default class HoistField<TContext = Record<string, any>> implements Transform<HoistFieldTransformationContext, TContext> {
     private readonly typeName;
     private readonly newFieldName;
     private readonly pathToField;
@@ -13,10 +15,11 @@ export default class HoistField implements Transform {
         fieldName: string;
         argFilter?: (arg: GraphQLArgument) => boolean;
     }>, newFieldName: string, alias?: string);
-    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig, transformedSchema?: GraphQLSchema): GraphQLSchema;
-    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext, transformationContext: Record<string, any>): ExecutionRequest;
-    transformResult(originalResult: ExecutionResult, delegationContext: DelegationContext, transformationContext: Record<string, any>): ExecutionResult;
+    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig<any, any, any, TContext>): GraphQLSchema;
+    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext<TContext>, transformationContext: HoistFieldTransformationContext): ExecutionRequest;
+    transformResult(originalResult: ExecutionResult, delegationContext: DelegationContext<TContext>, transformationContext: HoistFieldTransformationContext): ExecutionResult;
 }
 export declare function wrapFieldNode(fieldNode: FieldNode, path: Array<string>, alias: string, argLevels: Record<string, number>): FieldNode;
 export declare function renameFieldNode(fieldNode: FieldNode, name: string): FieldNode;
 export declare function unwrapValue(originalValue: any, alias: string): any;
+export {};

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

@@ -1,15 +1,18 @@
 import { GraphQLSchema } from 'graphql';
 import { ExecutionRequest, FieldNodeMappers, ExecutionResult } from '@graphql-tools/utils';
 import { Transform, DelegationContext, SubschemaConfig } from '@graphql-tools/delegate';
-import { ObjectValueTransformerMap, ErrorsTransformer } from '../types';
-export default class MapFields<TContext> implements Transform<any, TContext> {
+import { ObjectValueTransformerMap, ErrorsTransformer } from '../types.js';
+interface MapFieldsTransformationContext extends Record<string, any> {
+}
+export default class MapFields<TContext> implements Transform<MapFieldsTransformationContext, TContext> {
     private fieldNodeTransformerMap;
     private objectValueTransformerMap?;
     private errorsTransformer?;
     private transformer;
     constructor(fieldNodeTransformerMap: FieldNodeMappers, objectValueTransformerMap?: ObjectValueTransformerMap, errorsTransformer?: ErrorsTransformer);
     private _getTransformer;
-    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig<any, any, any, TContext>, transformedSchema?: GraphQLSchema): GraphQLSchema;
-    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext, transformationContext: Record<string, any>): ExecutionRequest;
-    transformResult(originalResult: ExecutionResult, delegationContext: DelegationContext, transformationContext: Record<string, any>): ExecutionResult;
+    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig<any, any, any, TContext>): GraphQLSchema;
+    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext<TContext>, transformationContext: MapFieldsTransformationContext): ExecutionRequest;
+    transformResult(originalResult: ExecutionResult, delegationContext: DelegationContext<TContext>, transformationContext: MapFieldsTransformationContext): ExecutionResult;
 }
+export {};

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

@@ -1,11 +1,11 @@
 import { GraphQLSchema } from 'graphql';
 import { ExecutionRequest, ExecutionResult } from '@graphql-tools/utils';
 import { Transform, DelegationContext, SubschemaConfig } from '@graphql-tools/delegate';
-import { LeafValueTransformer } from '../types';
+import { LeafValueTransformer } from '../types.js';
 export interface MapLeafValuesTransformationContext {
     transformedRequest: ExecutionRequest;
 }
-export default class MapLeafValues implements Transform<MapLeafValuesTransformationContext> {
+export default class MapLeafValues<TContext = Record<string, any>> implements Transform<MapLeafValuesTransformationContext, TContext> {
     private readonly inputValueTransformer;
     private readonly outputValueTransformer;
     private readonly resultVisitorMap;
@@ -14,9 +14,9 @@ export default class MapLeafValues implements Transform<MapLeafValuesTransformat
     constructor(inputValueTransformer: LeafValueTransformer, outputValueTransformer: LeafValueTransformer);
     private _getTypeInfo;
     private _getOriginalWrappingSchema;
-    transformSchema(originalWrappingSchema: GraphQLSchema, _subschemaConfig: SubschemaConfig, _transformedSchema?: GraphQLSchema): GraphQLSchema;
-    transformRequest(originalRequest: ExecutionRequest, _delegationContext: DelegationContext, transformationContext: MapLeafValuesTransformationContext): ExecutionRequest;
-    transformResult(originalResult: ExecutionResult, _delegationContext: DelegationContext, transformationContext: MapLeafValuesTransformationContext): ExecutionResult;
+    transformSchema(originalWrappingSchema: GraphQLSchema, _subschemaConfig: SubschemaConfig<any, any, any, TContext>): GraphQLSchema;
+    transformRequest(originalRequest: ExecutionRequest, _delegationContext: DelegationContext<TContext>, transformationContext: MapLeafValuesTransformationContext): ExecutionRequest;
+    transformResult(originalResult: ExecutionResult, _delegationContext: DelegationContext<TContext>, transformationContext: MapLeafValuesTransformationContext): ExecutionResult;
     private transformOperations;
     private transformFieldNode;
 }

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

@@ -1,8 +1,11 @@
 import { GraphQLSchema } from 'graphql';
 import { PruneSchemaOptions } from '@graphql-tools/utils';
 import { SubschemaConfig, Transform } from '@graphql-tools/delegate';
-export default class PruneTypes implements Transform {
+interface PruneTypesTransformationContext extends Record<string, any> {
+}
+export default class PruneTypes<TContext = Record<string, any>> implements Transform<PruneTypesTransformationContext, TContext> {
     private readonly options;
     constructor(options?: PruneSchemaOptions);
-    transformSchema(originalWrappingSchema: GraphQLSchema, _subschemaConfig: SubschemaConfig, _transformedSchema?: GraphQLSchema): GraphQLSchema;
+    transformSchema(originalWrappingSchema: GraphQLSchema, _subschemaConfig: SubschemaConfig<any, any, any, TContext>): GraphQLSchema;
 }
+export {};

package/typings/transforms/RemoveObjectFieldDeprecations.d.ts

@@ -0,0 +1,11 @@
+import { GraphQLSchema } from 'graphql';
+import { SubschemaConfig, Transform } from '@graphql-tools/delegate';
+interface RemoveObjectFieldDeprecationsTransformationContext extends Record<string, any> {
+}
+export default class RemoveObjectFieldDeprecations<TContext = Record<string, any>> implements Transform<RemoveObjectFieldDeprecationsTransformationContext, TContext> {
+    private readonly removeDirectives;
+    private readonly removeDeprecations;
+    constructor(reason: string | RegExp);
+    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig<any, any, any, TContext>): GraphQLSchema;
+}
+export {};

package/typings/transforms/RemoveObjectFieldDirectives.d.ts

@@ -0,0 +1,10 @@
+import { GraphQLSchema } from 'graphql';
+import { SubschemaConfig, Transform } from '@graphql-tools/delegate';
+interface RemoveObjectFieldDirectivesTransformationContext extends Record<string, any> {
+}
+export default class RemoveObjectFieldDirectives<TContext = Record<string, any>> implements Transform<RemoveObjectFieldDirectivesTransformationContext, TContext> {
+    private readonly transformer;
+    constructor(directiveName: string | RegExp, args?: Record<string, any>);
+    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig<any, any, any, TContext>): GraphQLSchema;
+}
+export {};

package/typings/transforms/RemoveObjectFieldsWithDeprecation.d.ts

@@ -0,0 +1,10 @@
+import { GraphQLSchema } from 'graphql';
+import { SubschemaConfig, Transform } from '@graphql-tools/delegate';
+interface RemoveObjectFieldsWithDeprecationTransformationContext extends Record<string, any> {
+}
+export default class RemoveObjectFieldsWithDeprecation<TContext = Record<string, any>> implements Transform<RemoveObjectFieldsWithDeprecationTransformationContext, TContext> {
+    private readonly transformer;
+    constructor(reason: string | RegExp);
+    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig<any, any, any, TContext>): GraphQLSchema;
+}
+export {};

package/typings/transforms/RemoveObjectFieldsWithDirective.d.ts

@@ -0,0 +1,11 @@
+import { GraphQLSchema } from 'graphql';
+import { SubschemaConfig, Transform } from '@graphql-tools/delegate';
+interface RemoveObjectFieldsWithDirectiveTransformationContext extends Record<string, any> {
+}
+export default class RemoveObjectFieldsWithDirective<TContext = Record<string, any>> implements Transform<RemoveObjectFieldsWithDirectiveTransformationContext, TContext> {
+    private readonly directiveName;
+    private readonly args;
+    constructor(directiveName: string | RegExp, args?: Record<string, any>);
+    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig<any, any, any, TContext>): GraphQLSchema;
+}
+export {};

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

@@ -2,12 +2,14 @@ import { GraphQLSchema, GraphQLInputFieldConfig } from 'graphql';
 import { ExecutionRequest } from '@graphql-tools/utils';
 import { Transform, DelegationContext, SubschemaConfig } from '@graphql-tools/delegate';
 declare type RenamerFunction = (typeName: string, fieldName: string, inputFieldConfig: GraphQLInputFieldConfig) => string | undefined;
-export default class RenameInputObjectFields implements Transform {
+interface RenameInputObjectFieldsTransformationContext extends Record<string, any> {
+}
+export default class RenameInputObjectFields<TContext = Record<string, any>> implements Transform<RenameInputObjectFieldsTransformationContext, TContext> {
     private readonly renamer;
     private readonly transformer;
     private reverseMap;
     constructor(renamer: RenamerFunction);
-    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig, transformedSchema?: GraphQLSchema): GraphQLSchema;
-    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext, transformationContext: Record<string, any>): ExecutionRequest;
+    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig<any, any, any, TContext>): GraphQLSchema;
+    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext<TContext>, transformationContext: RenameInputObjectFieldsTransformationContext): ExecutionRequest;
 }
 export {};

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

@@ -1,9 +1,12 @@
 import { GraphQLSchema, GraphQLFieldConfig } from 'graphql';
 import { ExecutionRequest } from '@graphql-tools/utils';
 import { Transform, DelegationContext, SubschemaConfig } from '@graphql-tools/delegate';
-export default class RenameInterfaceFields implements Transform {
+interface RenameInterfaceFieldsTransformationContext extends Record<string, any> {
+}
+export default class RenameInterfaceFields<TContext = Record<string, any>> implements Transform<RenameInterfaceFieldsTransformationContext, TContext> {
     private readonly transformer;
     constructor(renamer: (typeName: string, fieldName: string, fieldConfig: GraphQLFieldConfig<any, any>) => string);
-    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig, transformedSchema?: GraphQLSchema): GraphQLSchema;
-    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext, transformationContext: Record<string, any>): ExecutionRequest;
+    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig<any, any, any, TContext>): GraphQLSchema;
+    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext<TContext>, transformationContext: RenameInterfaceFieldsTransformationContext): ExecutionRequest;
 }
+export {};

package/typings/transforms/RenameObjectFieldArguments.d.ts

@@ -0,0 +1,15 @@
+import { GraphQLSchema } from 'graphql';
+import { ExecutionRequest } from '@graphql-tools/utils';
+import { Transform, DelegationContext, SubschemaConfig } from '@graphql-tools/delegate';
+declare type RenamerFunction = (typeName: string, fieldName: string, argName: string) => string;
+interface RenameObjectFieldArgumentsTransformationContext extends Record<string, any> {
+}
+export default class RenameObjectFieldArguments<TContext = Record<string, any>> implements Transform<RenameObjectFieldArgumentsTransformationContext, TContext> {
+    private readonly renamer;
+    private readonly transformer;
+    private reverseMap;
+    constructor(renamer: RenamerFunction);
+    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig<any, any, any, TContext>): GraphQLSchema;
+    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext<TContext>, transformationContext: RenameObjectFieldArgumentsTransformationContext): ExecutionRequest;
+}
+export {};

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

@@ -1,9 +1,12 @@
 import { GraphQLSchema, GraphQLFieldConfig } from 'graphql';
 import { ExecutionRequest } from '@graphql-tools/utils';
 import { Transform, DelegationContext, SubschemaConfig } from '@graphql-tools/delegate';
-export default class RenameObjectFields implements Transform {
+interface RenameObjectFieldsTransformationContext extends Record<string, any> {
+}
+export default class RenameObjectFields<TContext = Record<string, any>> implements Transform<RenameObjectFieldsTransformationContext, TContext> {
     private readonly transformer;
     constructor(renamer: (typeName: string, fieldName: string, fieldConfig: GraphQLFieldConfig<any, any>) => string);
-    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig, transformedSchema?: GraphQLSchema): GraphQLSchema;
-    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext, transformationContext: Record<string, any>): ExecutionRequest;
+    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig<any, any, any, TContext>): GraphQLSchema;
+    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext<TContext>, transformationContext: RenameObjectFieldsTransformationContext): ExecutionRequest;
 }
+export {};

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

@@ -1,9 +1,12 @@
 import { GraphQLSchema, GraphQLFieldConfig } from 'graphql';
 import { ExecutionRequest } from '@graphql-tools/utils';
 import { Transform, DelegationContext, SubschemaConfig } from '@graphql-tools/delegate';
-export default class RenameRootFields implements Transform {
+interface RenameRootFieldsTransformationContext extends Record<string, any> {
+}
+export default class RenameRootFields<TContext = Record<string, any>> implements Transform<RenameRootFieldsTransformationContext, TContext> {
     private readonly transformer;
     constructor(renamer: (operation: 'Query' | 'Mutation' | 'Subscription', name: string, fieldConfig: GraphQLFieldConfig<any, any>) => string);
-    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig, transformedSchema?: GraphQLSchema): GraphQLSchema;
-    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext, transformationContext: Record<string, any>): ExecutionRequest;
+    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig<any, any, any, TContext>): GraphQLSchema;
+    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext<TContext>, transformationContext: RenameRootFieldsTransformationContext): ExecutionRequest;
 }
+export {};

package/typings/transforms/RenameRootTypes.d.ts

@@ -0,0 +1,15 @@
+import { GraphQLSchema } from 'graphql';
+import { ExecutionRequest, ExecutionResult } from '@graphql-tools/utils';
+import { Transform, DelegationContext, SubschemaConfig } from '@graphql-tools/delegate';
+interface RenameRootTypesTransformationContext extends Record<string, any> {
+}
+export default class RenameRootTypes<TContext = Record<string, any>> implements Transform<RenameRootTypesTransformationContext, TContext> {
+    private readonly renamer;
+    private map;
+    private reverseMap;
+    constructor(renamer: (name: string) => string | undefined);
+    transformSchema(originalWrappingSchema: GraphQLSchema, _subschemaConfig: SubschemaConfig<any, any, any, TContext>): GraphQLSchema;
+    transformRequest(originalRequest: ExecutionRequest, _delegationContext: DelegationContext<TContext>, _transformationContext: RenameRootTypesTransformationContext): ExecutionRequest;
+    transformResult(originalResult: ExecutionResult, _delegationContext: DelegationContext<TContext>, _transformationContext?: RenameRootTypesTransformationContext): ExecutionResult;
+}
+export {};

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

@@ -1,14 +1,17 @@
 import { GraphQLSchema } from 'graphql';
 import { ExecutionRequest, ExecutionResult, RenameTypesOptions } from '@graphql-tools/utils';
 import { Transform, DelegationContext, SubschemaConfig } from '@graphql-tools/delegate';
-export default class RenameTypes implements Transform {
+interface RenameTypesTransformationContext extends Record<string, any> {
+}
+export default class RenameTypes<TContext = Record<string, any>> implements Transform<RenameTypesTransformationContext, TContext> {
     private readonly renamer;
     private map;
     private reverseMap;
     private readonly renameBuiltins;
     private readonly renameScalars;
     constructor(renamer: (name: string) => string | undefined, options?: RenameTypesOptions);
-    transformSchema(originalWrappingSchema: GraphQLSchema, _subschemaConfig: SubschemaConfig, _transformedSchema?: GraphQLSchema): GraphQLSchema;
-    transformRequest(originalRequest: ExecutionRequest, _delegationContext: DelegationContext, _transformationContext: Record<string, any>): ExecutionRequest;
-    transformResult(originalResult: ExecutionResult, _delegationContext: DelegationContext, _transformationContext?: Record<string, any>): ExecutionResult;
+    transformSchema(originalWrappingSchema: GraphQLSchema, _subschemaConfig: SubschemaConfig<any, any, any, TContext>): GraphQLSchema;
+    transformRequest(originalRequest: ExecutionRequest, _delegationContext: DelegationContext<TContext>, _transformationContext: RenameTypesTransformationContext): ExecutionRequest;
+    transformResult(originalResult: ExecutionResult, _delegationContext: DelegationContext<TContext>, _transformationContext?: RenameTypesTransformationContext): ExecutionResult;
 }
+export {};

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

@@ -1,8 +1,10 @@
 import { GraphQLSchema } from 'graphql';
 import { ExecutionRequest, ExecutionResult } from '@graphql-tools/utils';
 import { Transform, DelegationContext, SubschemaConfig } from '@graphql-tools/delegate';
-import { FieldTransformer, FieldNodeTransformer, DataTransformer, ErrorsTransformer } from '../types';
-export default class TransformCompositeFields<TContext = Record<string, any>> implements Transform<any, TContext> {
+import { FieldTransformer, FieldNodeTransformer, DataTransformer, ErrorsTransformer } from '../types.js';
+interface TransformCompositeFieldsTransformationContext extends Record<string, any> {
+}
+export default class TransformCompositeFields<TContext = Record<string, any>> implements Transform<TransformCompositeFieldsTransformationContext, TContext> {
     private readonly fieldTransformer;
     private readonly fieldNodeTransformer;
     private readonly dataTransformer;
@@ -11,11 +13,12 @@ export default class TransformCompositeFields<TContext = Record<string, any>> im
     private typeInfo;
     private mapping;
     private subscriptionTypeName;
-    constructor(fieldTransformer: FieldTransformer, fieldNodeTransformer?: FieldNodeTransformer, dataTransformer?: DataTransformer, errorsTransformer?: ErrorsTransformer);
+    constructor(fieldTransformer: FieldTransformer<TContext>, fieldNodeTransformer?: FieldNodeTransformer, dataTransformer?: DataTransformer, errorsTransformer?: ErrorsTransformer);
     private _getTypeInfo;
-    transformSchema(originalWrappingSchema: GraphQLSchema, _subschemaConfig: SubschemaConfig<any, any, any, TContext>, _transformedSchema?: GraphQLSchema): GraphQLSchema;
-    transformRequest(originalRequest: ExecutionRequest, _delegationContext: DelegationContext, transformationContext: Record<string, any>): ExecutionRequest;
-    transformResult(result: ExecutionResult, _delegationContext: DelegationContext, transformationContext: Record<string, any>): ExecutionResult;
+    transformSchema(originalWrappingSchema: GraphQLSchema, _subschemaConfig: SubschemaConfig<any, any, any, TContext>): GraphQLSchema;
+    transformRequest(originalRequest: ExecutionRequest, _delegationContext: DelegationContext<TContext>, transformationContext: TransformCompositeFieldsTransformationContext): ExecutionRequest;
+    transformResult(result: ExecutionResult, _delegationContext: DelegationContext<TContext>, transformationContext: TransformCompositeFieldsTransformationContext): ExecutionResult;
     private transformDocument;
     private transformSelectionSet;
 }
+export {};

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

@@ -1,17 +1,20 @@
 import { GraphQLSchema, ExecutionResult } from 'graphql';
 import { ExecutionRequest } from '@graphql-tools/utils';
 import { Transform, DelegationContext, SubschemaConfig } from '@graphql-tools/delegate';
-import { EnumValueTransformer, LeafValueTransformer } from '../types';
-import { MapLeafValuesTransformationContext } from './MapLeafValues';
-export default class TransformEnumValues implements Transform<MapLeafValuesTransformationContext> {
+import { EnumValueTransformer, LeafValueTransformer } from '../types.js';
+import { MapLeafValuesTransformationContext } from './MapLeafValues.js';
+interface TransformEnumValuesTransformationContext extends MapLeafValuesTransformationContext {
+}
+export default class TransformEnumValues<TContext = Record<string, any>> implements Transform<TransformEnumValuesTransformationContext, TContext> {
     private readonly enumValueTransformer;
     private readonly transformer;
     private transformedSchema;
     private mapping;
     private reverseMapping;
     constructor(enumValueTransformer: EnumValueTransformer, inputValueTransformer?: LeafValueTransformer, outputValueTransformer?: LeafValueTransformer);
-    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig, transformedSchema?: GraphQLSchema): GraphQLSchema;
-    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext, transformationContext: MapLeafValuesTransformationContext): ExecutionRequest;
-    transformResult(originalResult: ExecutionResult, delegationContext: DelegationContext, transformationContext: MapLeafValuesTransformationContext): import("@graphql-tools/utils").ExecutionResult<Record<string, any>>;
+    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig<any, any, any, TContext>): GraphQLSchema;
+    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext<TContext>, transformationContext: TransformEnumValuesTransformationContext): ExecutionRequest;
+    transformResult(originalResult: ExecutionResult, delegationContext: DelegationContext<TContext>, transformationContext: TransformEnumValuesTransformationContext): import("@graphql-tools/utils").ExecutionResult<Record<string, any>>;
     private transformEnumValue;
 }
+export {};

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

@@ -1,8 +1,10 @@
 import { GraphQLSchema } from 'graphql';
 import { ExecutionRequest } from '@graphql-tools/utils';
 import { Transform, DelegationContext, SubschemaConfig } from '@graphql-tools/delegate';
-import { InputFieldTransformer, InputFieldNodeTransformer, InputObjectNodeTransformer } from '../types';
-export default class TransformInputObjectFields implements Transform {
+import { InputFieldTransformer, InputFieldNodeTransformer, InputObjectNodeTransformer } from '../types.js';
+interface TransformInputObjectFieldsTransformationContext extends Record<string, any> {
+}
+export default class TransformInputObjectFields<TContext = Record<string, any>> implements Transform<TransformInputObjectFieldsTransformationContext, TContext> {
     private readonly inputFieldTransformer;
     private readonly inputFieldNodeTransformer;
     private readonly inputObjectNodeTransformer;
@@ -10,7 +12,8 @@ export default class TransformInputObjectFields implements Transform {
     private mapping;
     constructor(inputFieldTransformer: InputFieldTransformer, inputFieldNodeTransformer?: InputFieldNodeTransformer, inputObjectNodeTransformer?: InputObjectNodeTransformer);
     private _getTransformedSchema;
-    transformSchema(originalWrappingSchema: GraphQLSchema, _subschemaConfig: SubschemaConfig, _transformedSchema?: GraphQLSchema): GraphQLSchema;
-    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext, _transformationContext: Record<string, any>): ExecutionRequest;
+    transformSchema(originalWrappingSchema: GraphQLSchema, _subschemaConfig: SubschemaConfig<any, any, any, TContext>): GraphQLSchema;
+    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext<TContext>, _transformationContext: TransformInputObjectFieldsTransformationContext): ExecutionRequest;
     private transformDocument;
 }
+export {};