@graphql-tools/wrap - npm Package Compare versions

Comparing version 6.0.7 to 6.0.8-alpha-0e1d910.0

index.cjs.js

@@ -623,2 +623,192 @@ 'use strict';
 
+class TransformInputObjectFields {
+    constructor(inputFieldTransformer, inputFieldNodeTransformer, inputObjectNodeTransformer) {
+        this.inputFieldTransformer = inputFieldTransformer;
+        this.inputFieldNodeTransformer = inputFieldNodeTransformer;
+        this.inputObjectNodeTransformer = inputObjectNodeTransformer;
+        this.mapping = {};
+    }
+    transformSchema(originalSchema) {
+        this.transformedSchema = utils.mapSchema(originalSchema, {
+            [utils.MapperKind.INPUT_OBJECT_TYPE]: (type) => this.transformFields(type, this.inputFieldTransformer),
+        });
+        return this.transformedSchema;
+    }
+    transformRequest(originalRequest, delegationContext) {
+        const fragments = Object.create(null);
+        originalRequest.document.definitions
+            .filter(def => def.kind === graphql.Kind.FRAGMENT_DEFINITION)
+            .forEach(def => {
+            fragments[def.name.value] = def;
+        });
+        const document = this.transformDocument(originalRequest.document, this.mapping, this.inputFieldNodeTransformer, this.inputObjectNodeTransformer, delegationContext, originalRequest);
+        return {
+            ...originalRequest,
+            document,
+        };
+    }
+    transformFields(type, inputFieldTransformer) {
+        const config = type.toConfig();
+        const originalInputFieldConfigMap = config.fields;
+        const newInputFieldConfigMap = {};
+        Object.keys(originalInputFieldConfigMap).forEach(fieldName => {
+            const originalInputFieldConfig = originalInputFieldConfigMap[fieldName];
+            const transformedField = inputFieldTransformer(type.name, fieldName, originalInputFieldConfig);
+            if (transformedField === undefined) {
+                newInputFieldConfigMap[fieldName] = originalInputFieldConfig;
+            }
+            else if (Array.isArray(transformedField)) {
+                const newFieldName = transformedField[0];
+                const newFieldConfig = transformedField[1];
+                newInputFieldConfigMap[newFieldName] = newFieldConfig;
+                if (newFieldName !== fieldName) {
+                    const typeName = type.name;
+                    if (!(typeName in this.mapping)) {
+                        this.mapping[typeName] = {};
+                    }
+                    this.mapping[typeName][newFieldName] = fieldName;
+                }
+            }
+            else if (transformedField != null) {
+                newInputFieldConfigMap[fieldName] = transformedField;
+            }
+        });
+        if (!Object.keys(newInputFieldConfigMap).length) {
+            return null;
+        }
+        return new graphql.GraphQLInputObjectType({
+            ...type.toConfig(),
+            fields: newInputFieldConfigMap,
+        });
+    }
+    transformDocument(document, mapping, inputFieldNodeTransformer, inputObjectNodeTransformer, delegationContext, request) {
+        const typeInfo = new graphql.TypeInfo(this.transformedSchema);
+        const newDocument = graphql.visit(document, graphql.visitWithTypeInfo(typeInfo, {
+            leave: {
+                [graphql.Kind.OBJECT]: (node) => {
+                    const parentType = typeInfo.getInputType();
+                    if (parentType != null) {
+                        const parentTypeName = parentType.name;
+                        const newInputFields = [];
+                        node.fields.forEach(inputField => {
+                            const newName = inputField.name.value;
+                            const transformedInputField = inputFieldNodeTransformer != null
+                                ? inputFieldNodeTransformer(parentTypeName, newName, inputField, delegationContext, request)
+                                : inputField;
+                            if (Array.isArray(transformedInputField)) {
+                                transformedInputField.forEach(individualTransformedInputField => {
+                                    const typeMapping = mapping[parentTypeName];
+                                    if (typeMapping == null) {
+                                        newInputFields.push(individualTransformedInputField);
+                                        return;
+                                    }
+                                    const oldName = typeMapping[newName];
+                                    if (oldName == null) {
+                                        newInputFields.push(individualTransformedInputField);
+                                        return;
+                                    }
+                                    newInputFields.push({
+                                        ...individualTransformedInputField,
+                                        name: {
+                                            ...individualTransformedInputField.name,
+                                            value: oldName,
+                                        },
+                                    });
+                                });
+                                return;
+                            }
+                            const typeMapping = mapping[parentTypeName];
+                            if (typeMapping == null) {
+                                newInputFields.push(transformedInputField);
+                                return;
+                            }
+                            const oldName = typeMapping[newName];
+                            if (oldName == null) {
+                                newInputFields.push(transformedInputField);
+                                return;
+                            }
+                            newInputFields.push({
+                                ...transformedInputField,
+                                name: {
+                                    ...transformedInputField.name,
+                                    value: oldName,
+                                },
+                            });
+                        });
+                        const newNode = {
+                            ...node,
+                            fields: newInputFields,
+                        };
+                        return inputObjectNodeTransformer != null
+                            ? inputObjectNodeTransformer(parentTypeName, newNode, delegationContext, request)
+                            : newNode;
+                    }
+                },
+            },
+        }));
+        return newDocument;
+    }
+}
+
+class RenameInputObjectFields {
+    constructor(renamer) {
+        this.renamer = renamer;
+        this.transformer = new TransformInputObjectFields((typeName, inputFieldName, inputFieldConfig) => {
+            const newName = renamer(typeName, inputFieldName, inputFieldConfig);
+            if (newName !== undefined && newName !== inputFieldName) {
+                return [renamer(typeName, inputFieldName, inputFieldConfig), inputFieldConfig];
+            }
+        }, (typeName, inputFieldName, inputFieldNode) => {
+            if (!(typeName in this.reverseMap)) {
+                return inputFieldNode;
+            }
+            const inputFieldNameMap = this.reverseMap[typeName];
+            if (!(inputFieldName in inputFieldNameMap)) {
+                return inputFieldNode;
+            }
+            return {
+                ...inputFieldNode,
+                name: {
+                    ...inputFieldNode.name,
+                    value: inputFieldNameMap[inputFieldName],
+                },
+            };
+        });
+        this.reverseMap = Object.create(null);
+    }
+    transformSchema(originalSchema) {
+        utils.mapSchema(originalSchema, {
+            [utils.MapperKind.INPUT_OBJECT_FIELD]: (inputFieldConfig, fieldName, typeName) => {
+                const newName = this.renamer(typeName, fieldName, inputFieldConfig);
+                if (newName !== undefined && newName !== fieldName) {
+                    if (this.reverseMap[typeName] == null) {
+                        this.reverseMap[typeName] = Object.create(null);
+                    }
+                    this.reverseMap[typeName][newName] = fieldName;
+                }
+                return undefined;
+            },
+            [utils.MapperKind.ROOT_OBJECT]() {
+                return undefined;
+            },
+        });
+        return this.transformer.transformSchema(originalSchema);
+    }
+    transformRequest(originalRequest, delegationContext) {
+        return this.transformer.transformRequest(originalRequest, delegationContext);
+    }
+}
+
+class FilterInputObjectFields {
+    constructor(filter, inputObjectNodeTransformer) {
+        this.transformer = new TransformInputObjectFields((typeName, fieldName, inputFieldConfig) => filter(typeName, fieldName, inputFieldConfig) ? undefined : null, undefined, inputObjectNodeTransformer);
+    }
+    transformSchema(originalSchema) {
+        return this.transformer.transformSchema(originalSchema);
+    }
+    transformRequest(originalRequest, delegationContext) {
+        return this.transformer.transformRequest(originalRequest, delegationContext);
+    }
+}
+
 class TransformQuery {
@@ -1007,2 +1197,3 @@ constructor({ path, queryTransformer, resultTransformer = result => result, errorPathTransformer = errorPath => [].concat(errorPath), fragments = {}, }) {
 exports.ExtractField = ExtractField;
+exports.FilterInputObjectFields = FilterInputObjectFields;
 exports.FilterInterfaceFields = FilterInterfaceFields;
@@ -1014,2 +1205,3 @@ exports.FilterObjectFields = FilterObjectFields;
 exports.MapFields = MapFields;
+exports.RenameInputObjectFields = RenameInputObjectFields;
 exports.RenameInterfaceFields = RenameInterfaceFields;
@@ -1021,2 +1213,3 @@ exports.RenameObjectFields = RenameObjectFields;
 exports.TransformCompositeFields = TransformCompositeFields;
+exports.TransformInputObjectFields = TransformInputObjectFields;
 exports.TransformInterfaceFields = TransformInterfaceFields;
@@ -1023,0 +1216,0 @@ exports.TransformObjectFields = TransformObjectFields;

index.esm.js

@@ -619,2 +619,192 @@ import { GraphQLObjectType, GraphQLInterfaceType, GraphQLUnionType, isSpecifiedScalarType, isScalarType, isObjectType, isInterfaceType, isUnionType, isInputObjectType, GraphQLInputObjectType, isEnumType, GraphQLEnumType, GraphQLScalarType, visit, Kind, TypeInfo, visitWithTypeInfo, extendSchema, parse, getNullableType, BREAK, buildSchema, getIntrospectionQuery, buildClientSchema } from 'graphql';
 
+class TransformInputObjectFields {
+    constructor(inputFieldTransformer, inputFieldNodeTransformer, inputObjectNodeTransformer) {
+        this.inputFieldTransformer = inputFieldTransformer;
+        this.inputFieldNodeTransformer = inputFieldNodeTransformer;
+        this.inputObjectNodeTransformer = inputObjectNodeTransformer;
+        this.mapping = {};
+    }
+    transformSchema(originalSchema) {
+        this.transformedSchema = mapSchema(originalSchema, {
+            [MapperKind.INPUT_OBJECT_TYPE]: (type) => this.transformFields(type, this.inputFieldTransformer),
+        });
+        return this.transformedSchema;
+    }
+    transformRequest(originalRequest, delegationContext) {
+        const fragments = Object.create(null);
+        originalRequest.document.definitions
+            .filter(def => def.kind === Kind.FRAGMENT_DEFINITION)
+            .forEach(def => {
+            fragments[def.name.value] = def;
+        });
+        const document = this.transformDocument(originalRequest.document, this.mapping, this.inputFieldNodeTransformer, this.inputObjectNodeTransformer, delegationContext, originalRequest);
+        return {
+            ...originalRequest,
+            document,
+        };
+    }
+    transformFields(type, inputFieldTransformer) {
+        const config = type.toConfig();
+        const originalInputFieldConfigMap = config.fields;
+        const newInputFieldConfigMap = {};
+        Object.keys(originalInputFieldConfigMap).forEach(fieldName => {
+            const originalInputFieldConfig = originalInputFieldConfigMap[fieldName];
+            const transformedField = inputFieldTransformer(type.name, fieldName, originalInputFieldConfig);
+            if (transformedField === undefined) {
+                newInputFieldConfigMap[fieldName] = originalInputFieldConfig;
+            }
+            else if (Array.isArray(transformedField)) {
+                const newFieldName = transformedField[0];
+                const newFieldConfig = transformedField[1];
+                newInputFieldConfigMap[newFieldName] = newFieldConfig;
+                if (newFieldName !== fieldName) {
+                    const typeName = type.name;
+                    if (!(typeName in this.mapping)) {
+                        this.mapping[typeName] = {};
+                    }
+                    this.mapping[typeName][newFieldName] = fieldName;
+                }
+            }
+            else if (transformedField != null) {
+                newInputFieldConfigMap[fieldName] = transformedField;
+            }
+        });
+        if (!Object.keys(newInputFieldConfigMap).length) {
+            return null;
+        }
+        return new GraphQLInputObjectType({
+            ...type.toConfig(),
+            fields: newInputFieldConfigMap,
+        });
+    }
+    transformDocument(document, mapping, inputFieldNodeTransformer, inputObjectNodeTransformer, delegationContext, request) {
+        const typeInfo = new TypeInfo(this.transformedSchema);
+        const newDocument = visit(document, visitWithTypeInfo(typeInfo, {
+            leave: {
+                [Kind.OBJECT]: (node) => {
+                    const parentType = typeInfo.getInputType();
+                    if (parentType != null) {
+                        const parentTypeName = parentType.name;
+                        const newInputFields = [];
+                        node.fields.forEach(inputField => {
+                            const newName = inputField.name.value;
+                            const transformedInputField = inputFieldNodeTransformer != null
+                                ? inputFieldNodeTransformer(parentTypeName, newName, inputField, delegationContext, request)
+                                : inputField;
+                            if (Array.isArray(transformedInputField)) {
+                                transformedInputField.forEach(individualTransformedInputField => {
+                                    const typeMapping = mapping[parentTypeName];
+                                    if (typeMapping == null) {
+                                        newInputFields.push(individualTransformedInputField);
+                                        return;
+                                    }
+                                    const oldName = typeMapping[newName];
+                                    if (oldName == null) {
+                                        newInputFields.push(individualTransformedInputField);
+                                        return;
+                                    }
+                                    newInputFields.push({
+                                        ...individualTransformedInputField,
+                                        name: {
+                                            ...individualTransformedInputField.name,
+                                            value: oldName,
+                                        },
+                                    });
+                                });
+                                return;
+                            }
+                            const typeMapping = mapping[parentTypeName];
+                            if (typeMapping == null) {
+                                newInputFields.push(transformedInputField);
+                                return;
+                            }
+                            const oldName = typeMapping[newName];
+                            if (oldName == null) {
+                                newInputFields.push(transformedInputField);
+                                return;
+                            }
+                            newInputFields.push({
+                                ...transformedInputField,
+                                name: {
+                                    ...transformedInputField.name,
+                                    value: oldName,
+                                },
+                            });
+                        });
+                        const newNode = {
+                            ...node,
+                            fields: newInputFields,
+                        };
+                        return inputObjectNodeTransformer != null
+                            ? inputObjectNodeTransformer(parentTypeName, newNode, delegationContext, request)
+                            : newNode;
+                    }
+                },
+            },
+        }));
+        return newDocument;
+    }
+}
+
+class RenameInputObjectFields {
+    constructor(renamer) {
+        this.renamer = renamer;
+        this.transformer = new TransformInputObjectFields((typeName, inputFieldName, inputFieldConfig) => {
+            const newName = renamer(typeName, inputFieldName, inputFieldConfig);
+            if (newName !== undefined && newName !== inputFieldName) {
+                return [renamer(typeName, inputFieldName, inputFieldConfig), inputFieldConfig];
+            }
+        }, (typeName, inputFieldName, inputFieldNode) => {
+            if (!(typeName in this.reverseMap)) {
+                return inputFieldNode;
+            }
+            const inputFieldNameMap = this.reverseMap[typeName];
+            if (!(inputFieldName in inputFieldNameMap)) {
+                return inputFieldNode;
+            }
+            return {
+                ...inputFieldNode,
+                name: {
+                    ...inputFieldNode.name,
+                    value: inputFieldNameMap[inputFieldName],
+                },
+            };
+        });
+        this.reverseMap = Object.create(null);
+    }
+    transformSchema(originalSchema) {
+        mapSchema(originalSchema, {
+            [MapperKind.INPUT_OBJECT_FIELD]: (inputFieldConfig, fieldName, typeName) => {
+                const newName = this.renamer(typeName, fieldName, inputFieldConfig);
+                if (newName !== undefined && newName !== fieldName) {
+                    if (this.reverseMap[typeName] == null) {
+                        this.reverseMap[typeName] = Object.create(null);
+                    }
+                    this.reverseMap[typeName][newName] = fieldName;
+                }
+                return undefined;
+            },
+            [MapperKind.ROOT_OBJECT]() {
+                return undefined;
+            },
+        });
+        return this.transformer.transformSchema(originalSchema);
+    }
+    transformRequest(originalRequest, delegationContext) {
+        return this.transformer.transformRequest(originalRequest, delegationContext);
+    }
+}
+
+class FilterInputObjectFields {
+    constructor(filter, inputObjectNodeTransformer) {
+        this.transformer = new TransformInputObjectFields((typeName, fieldName, inputFieldConfig) => filter(typeName, fieldName, inputFieldConfig) ? undefined : null, undefined, inputObjectNodeTransformer);
+    }
+    transformSchema(originalSchema) {
+        return this.transformer.transformSchema(originalSchema);
+    }
+    transformRequest(originalRequest, delegationContext) {
+        return this.transformer.transformRequest(originalRequest, delegationContext);
+    }
+}
+
 class TransformQuery {
@@ -1001,3 +1191,3 @@ constructor({ path, queryTransformer, resultTransformer = result => result, errorPathTransformer = errorPath => [].concat(errorPath), fragments = {}, }) {
 
-export { ExtendSchema, ExtractField, FilterInterfaceFields, FilterObjectFields, FilterRootFields, FilterTypes, HoistField, MapFields, RenameInterfaceFields, RenameObjectFields, RenameRootFields, RenameRootTypes, RenameTypes, TransformCompositeFields, TransformInterfaceFields, TransformObjectFields, TransformQuery, TransformRootFields, WrapFields, WrapQuery, WrapType, defaultCreateProxyingResolver, defaultCreateRemoteResolver, generateProxyingResolvers, introspectSchema, introspectSchemaSync, makeRemoteExecutableSchema, wrapSchema };
+export { ExtendSchema, ExtractField, FilterInputObjectFields, FilterInterfaceFields, FilterObjectFields, FilterRootFields, FilterTypes, HoistField, MapFields, RenameInputObjectFields, RenameInterfaceFields, RenameObjectFields, RenameRootFields, RenameRootTypes, RenameTypes, TransformCompositeFields, TransformInputObjectFields, TransformInterfaceFields, TransformObjectFields, TransformQuery, TransformRootFields, WrapFields, WrapQuery, WrapType, defaultCreateProxyingResolver, defaultCreateRemoteResolver, generateProxyingResolvers, introspectSchema, introspectSchemaSync, makeRemoteExecutableSchema, wrapSchema };
 //# sourceMappingURL=index.esm.js.map

package.json

 {
   "name": "@graphql-tools/wrap",
-  "version": "6.0.7",
+  "version": "6.0.8-alpha-0e1d910.0",
   "description": "A set of utils for faster development of GraphQL tools",
@@ -10,5 +10,5 @@ "sideEffects": false,
   "dependencies": {
-    "@graphql-tools/delegate": "6.0.7",
-    "@graphql-tools/schema": "6.0.7",
-    "@graphql-tools/utils": "6.0.7",
+    "@graphql-tools/delegate": "6.0.8-alpha-0e1d910.0",
+    "@graphql-tools/schema": "6.0.8-alpha-0e1d910.0",
+    "@graphql-tools/utils": "6.0.8-alpha-0e1d910.0",
     "tslib": "~2.0.0"
@@ -15,0 +15,0 @@ },

transforms/index.d.ts

@@ -14,2 +14,5 @@ export { default as RenameTypes } from './RenameTypes';
 export { default as FilterInterfaceFields } from './FilterInterfaceFields';
+export { default as TransformInputObjectFields } from './TransformInputObjectFields';
+export { default as RenameInputObjectFields } from './RenameInputObjectFields';
+export { default as FilterInputObjectFields } from './FilterInputObjectFields';
 export { default as TransformQuery } from './TransformQuery';
@@ -16,0 +19,0 @@ export { default as ExtendSchema } from './ExtendSchema';

types.d.ts

@@ -1,3 +0,4 @@
-import { GraphQLSchema, GraphQLFieldResolver, BuildSchemaOptions, GraphQLFieldConfig, FieldNode, FragmentDefinitionNode, SelectionNode } from 'graphql';
-import { Executor, Subscriber } from '@graphql-tools/delegate';
+import { GraphQLSchema, GraphQLFieldResolver, BuildSchemaOptions, GraphQLInputFieldConfig, GraphQLFieldConfig, FieldNode, FragmentDefinitionNode, SelectionNode, ObjectFieldNode, ObjectValueNode } from 'graphql';
+import { Executor, Subscriber, DelegationContext } from '@graphql-tools/delegate';
+import { Request } from '@graphql-tools/utils';
 export interface IMakeRemoteExecutableSchemaOptions {
@@ -10,4 +11,7 @@ schema: GraphQLSchema | string;
 }
+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, delegationContext: DelegationContext, request: Request) => ObjectFieldNode | Array<ObjectFieldNode>;
+export declare type InputObjectNodeTransformer = (typeName: string, inputObjectNode: ObjectValueNode, delegationContext: DelegationContext, request: Request) => ObjectValueNode;
 export declare type FieldTransformer = (typeName: string, fieldName: string, fieldConfig: GraphQLFieldConfig<any, any>) => GraphQLFieldConfig<any, any> | [string, GraphQLFieldConfig<any, any>] | null | undefined;
 export declare type RootFieldTransformer = (operation: 'Query' | 'Mutation' | 'Subscription', fieldName: string, fieldConfig: GraphQLFieldConfig<any, any>) => GraphQLFieldConfig<any, any> | [string, GraphQLFieldConfig<any, any>] | null | undefined;
 export declare type FieldNodeTransformer = (typeName: string, fieldName: string, fieldNode: FieldNode, fragments: Record<string, FragmentDefinitionNode>) => SelectionNode | Array<SelectionNode>;

New alerts

No v1

Quality

Package is not semver >=1. This means it is not stable and does not support ^ ranges.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

313248

increased by21.56%

Number of package files

36

increased by9.09%

Lines of code

2688

increased by18.62%

Worsened metrics

Number of low quality alerts

2

increased by100%

Dependency changes

• + Added@graphql-tools/delegate@6.0.8-alpha-0e1d910.0(transitive)

• + Added@graphql-tools/schema@6.0.8-alpha-0e1d910.0(transitive)

• + Added@graphql-tools/utils@6.0.8-alpha-0e1d910.0(transitive)

• - Removed@graphql-tools/delegate@6.0.7(transitive)

• - Removed@graphql-tools/schema@6.0.7(transitive)

• - Removed@graphql-tools/utils@6.0.7(transitive)

• Updated@graphql-tools/delegate@6.0.8-alpha-0e1d910.0

• Updated@graphql-tools/schema@6.0.8-alpha-0e1d910.0

• Updated@graphql-tools/utils@6.0.8-alpha-0e1d910.0