@graphql-toolkit/common - npm Package Compare versions

Comparing version 0.10.3-alpha-475ea3f.3 to 0.10.3-alpha-87df00e.5

extract-resolvers-from-schema.d.ts

 import { GraphQLSchema, DocumentNode } from 'graphql';
-import { IResolvers } from 'graphql-tools-fork';
+import { IResolvers } from '@graphql-toolkit/types';
 export interface ExtractResolversFromSchemaOptions {
@@ -4,0 +4,0 @@ selectedTypeDefs?: DocumentNode;

index.cjs.js

@@ -27,5 +27,5 @@ 'use strict';
 const graphql = require('graphql');
-const graphqlToolsFork = require('graphql-tools-fork');
 const AggregateError = _interopDefault(require('aggregate-error'));
-const lodash = require('lodash');
+const get = _interopDefault(require('lodash.get'));
+const set = _interopDefault(require('lodash.set'));
 const camelCase = require('camel-case');
@@ -149,73 +149,2 @@
 
-function extractFieldResolversFromObjectType(objectType, options) {
-    const fieldResolvers = {};
-    const fieldMap = objectType.getFields();
-    let selectedFieldNames;
-    if (options && options.selectedTypeDefs) {
-        const invalidSchema = graphql.buildASTSchema(options.selectedTypeDefs);
-        const typeMap = invalidSchema.getTypeMap();
-        if (!(objectType.name in typeMap)) {
-            return {};
-        }
-        const selectedObjectType = typeMap[objectType.name];
-        selectedFieldNames = Object.keys(selectedObjectType.getFields());
-    }
-    for (const fieldName in fieldMap) {
-        if (selectedFieldNames && !selectedFieldNames.includes(fieldName)) {
-            continue;
-        }
-        const fieldDefinition = fieldMap[fieldName];
-        fieldResolvers[fieldName] = {
-            subscribe: fieldDefinition.subscribe,
-            resolve: fieldDefinition.resolve,
-        };
-    }
-    if ('resolveType' in objectType) {
-        fieldResolvers['__resolveType'] = objectType.resolveType;
-    }
-    if ('isTypeOf' in objectType) {
-        fieldResolvers['__isTypeOf'] = objectType.isTypeOf;
-    }
-    return fieldResolvers;
-}
-
-function extractResolversFromSchema(schema, options) {
-    let selectedTypeNames;
-    const resolvers = {};
-    const typeMap = schema.getTypeMap();
-    if (options && options.selectedTypeDefs) {
-        const invalidSchema = graphql.buildASTSchema(options.selectedTypeDefs);
-        selectedTypeNames = Object.keys(invalidSchema.getTypeMap());
-    }
-    for (const typeName in typeMap) {
-        if (!typeName.startsWith('__')) {
-            const typeDef = typeMap[typeName];
-            if (selectedTypeNames && !selectedTypeNames.includes(typeName)) {
-                continue;
-            }
-            if (graphql.isScalarType(typeDef)) {
-                resolvers[typeName] = typeDef;
-            }
-            else if (graphql.isObjectType(typeDef) || graphql.isInterfaceType(typeDef)) {
-                resolvers[typeName] = extractFieldResolversFromObjectType(typeDef, {
-                    selectedTypeDefs: options && options.selectedTypeDefs,
-                });
-            }
-            else if (graphql.isEnumType(typeDef)) {
-                const enumValues = typeDef.getValues();
-                resolvers[typeName] = {};
-                for (const { name, value } of enumValues) {
-                    resolvers[typeName][name] = value;
-                }
-            }
-            else if (graphql.isUnionType(typeDef)) {
-                resolvers[typeName] = {
-                    __resolveType: typeDef.resolveType,
-                };
-            }
-        }
-    }
-    return resolvers;
-}
-
 const fixWindowsPath = (path) => path.replace(/\\/g, '/');
@@ -299,16 +228,2 @@
 
-function getSchemaDirectiveFromDirectiveResolver(directiveResolver) {
-    return class extends graphqlToolsFork.SchemaDirectiveVisitor {
-        visitFieldDefinition(field) {
-            const resolver = directiveResolver;
-            const originalResolver = field.resolve || graphql.defaultFieldResolver;
-            const directiveArgs = this.args;
-            field.resolve = (...args) => {
-                const [source /* original args */, , context, info] = args;
-                return resolver(async () => originalResolver.apply(field, args), source, directiveArgs, context, info);
-            };
-        }
-    };
-}
-
 function createSchemaDefinition(def, config) {
@@ -531,4 +446,4 @@ const schemaRoot = {};
     Object.keys(mappingResult).forEach((path) => {
-        const fns = chainFunctions([...asArray(mappingResult[path]), () => lodash.get(resolvers, path)]);
-        lodash.set(resolvers, path, fns());
+        const fns = chainFunctions([...asArray(mappingResult[path]), () => get(resolvers, path)]);
+        set(resolvers, path, fns());
     });
@@ -1009,2 +924,257 @@ return resolvers;
 
+// @schemaDefinition: A GraphQL type schema in shorthand
+// @resolvers: Definitions for resolvers to be merged with schema
+class SchemaError extends Error {
+    constructor(message) {
+        super(message);
+        this.message = message;
+        Error.captureStackTrace(this, this.constructor);
+    }
+}
+
+function forEachField(schema, fn) {
+    const typeMap = schema.getTypeMap();
+    Object.keys(typeMap).forEach((typeName) => {
+        const type = typeMap[typeName];
+        // TODO: maybe have an option to include these?
+        if (!graphql.getNamedType(type).name.startsWith('__') && graphql.isObjectType(type)) {
+            const fields = type.getFields();
+            Object.keys(fields).forEach((fieldName) => {
+                const field = fields[fieldName];
+                fn(field, typeName, fieldName);
+            });
+        }
+    });
+}
+function forEachDefaultValue(schema, fn) {
+    const typeMap = schema.getTypeMap();
+    Object.keys(typeMap).forEach((typeName) => {
+        const type = typeMap[typeName];
+        if (!graphql.getNamedType(type).name.startsWith('__')) {
+            if (graphql.isObjectType(type)) {
+                const fields = type.getFields();
+                Object.keys(fields).forEach((fieldName) => {
+                    const field = fields[fieldName];
+                    field.args.forEach((arg) => {
+                        arg.defaultValue = fn(arg.type, arg.defaultValue);
+                    });
+                });
+            }
+            else if (graphql.isInputObjectType(type)) {
+                const fields = type.getFields();
+                Object.keys(fields).forEach((fieldName) => {
+                    const field = fields[fieldName];
+                    field.defaultValue = fn(field.type, field.defaultValue);
+                });
+            }
+        }
+    });
+}
+// A more powerful version of each that has the ability to replace or remove
+// array or object keys.
+function updateEachKey(arrayOrObject, 
+// The callback can return nothing to leave the key untouched, null to remove
+// the key from the array or object, or a non-null V to replace the value.
+updater) {
+    let deletedCount = 0;
+    Object.keys(arrayOrObject).forEach((key) => {
+        const result = updater(arrayOrObject[key], key);
+        if (typeof result === 'undefined') {
+            return;
+        }
+        if (result === null) {
+            delete arrayOrObject[key];
+            deletedCount++;
+            return;
+        }
+        arrayOrObject[key] = result;
+    });
+    if (deletedCount > 0 && Array.isArray(arrayOrObject)) {
+        // Remove any holes from the array due to deleted elements.
+        arrayOrObject.splice(0).forEach((elem) => {
+            arrayOrObject.push(elem);
+        });
+    }
+}
+function each(arrayOrObject, callback) {
+    Object.keys(arrayOrObject).forEach((key) => {
+        callback(arrayOrObject[key], key);
+    });
+}
+
+function mergeDeep(target, ...sources) {
+    const output = {
+        ...target,
+    };
+    sources.forEach((source) => {
+        if (isObject(target) && isObject(source)) {
+            Object.keys(source).forEach((key) => {
+                if (isObject(source[key])) {
+                    if (!(key in target)) {
+                        Object.assign(output, { [key]: source[key] });
+                    }
+                    else {
+                        output[key] = mergeDeep(target[key], source[key]);
+                    }
+                }
+                else {
+                    Object.assign(output, { [key]: source[key] });
+                }
+            });
+        }
+    });
+    return output;
+}
+function isObject(item) {
+    return item && typeof item === 'object' && !Array.isArray(item);
+}
+
+function createNamedStub(name, type) {
+    let constructor;
+    if (type === 'object') {
+        constructor = graphql.GraphQLObjectType;
+    }
+    else if (type === 'interface') {
+        constructor = graphql.GraphQLInterfaceType;
+    }
+    else {
+        constructor = graphql.GraphQLInputObjectType;
+    }
+    return new constructor({
+        name,
+        fields: {
+            __fake: {
+                type: graphql.GraphQLString,
+            },
+        },
+    });
+}
+function isStub(type) {
+    if (graphql.isObjectType(type) || graphql.isInterfaceType(type) || graphql.isInputObjectType(type)) {
+        const fields = type.getFields();
+        const fieldNames = Object.keys(fields);
+        return fieldNames.length === 1 && fields[fieldNames[0]].name === '__fake';
+    }
+    return false;
+}
+function getBuiltInForStub(type) {
+    switch (type.name) {
+        case graphql.GraphQLInt.name:
+            return graphql.GraphQLInt;
+        case graphql.GraphQLFloat.name:
+            return graphql.GraphQLFloat;
+        case graphql.GraphQLString.name:
+            return graphql.GraphQLString;
+        case graphql.GraphQLBoolean.name:
+            return graphql.GraphQLBoolean;
+        case graphql.GraphQLID.name:
+            return graphql.GraphQLID;
+        default:
+            return type;
+    }
+}
+
+function transformInputValue(type, value, transformer) {
+    if (value == null) {
+        return value;
+    }
+    const nullableType = graphql.getNullableType(type);
+    if (graphql.isLeafType(nullableType)) {
+        return transformer(nullableType, value);
+    }
+    else if (graphql.isListType(nullableType)) {
+        return value.map((listMember) => transformInputValue(nullableType.ofType, listMember, transformer));
+    }
+    else if (graphql.isInputObjectType(nullableType)) {
+        const fields = nullableType.getFields();
+        const newValue = {};
+        Object.keys(value).forEach((key) => {
+            newValue[key] = transformInputValue(fields[key].type, value[key], transformer);
+        });
+        return newValue;
+    }
+    // unreachable, no other possible return value
+}
+function serializeInputValue(type, value) {
+    return transformInputValue(type, value, (t, v) => t.serialize(v));
+}
+function parseInputValue(type, value) {
+    return transformInputValue(type, value, (t, v) => t.parseValue(v));
+}
+function parseInputValueLiteral(type, value) {
+    return transformInputValue(type, value, (t, v) => t.parseLiteral(v, {}));
+}
+
+function extractFieldResolversFromObjectType(objectType, options) {
+    const fieldResolvers = {};
+    const fieldMap = objectType.getFields();
+    let selectedFieldNames;
+    if (options && options.selectedTypeDefs) {
+        const invalidSchema = graphql.buildASTSchema(options.selectedTypeDefs);
+        const typeMap = invalidSchema.getTypeMap();
+        if (!(objectType.name in typeMap)) {
+            return {};
+        }
+        const selectedObjectType = typeMap[objectType.name];
+        selectedFieldNames = Object.keys(selectedObjectType.getFields());
+    }
+    for (const fieldName in fieldMap) {
+        if (selectedFieldNames && !selectedFieldNames.includes(fieldName)) {
+            continue;
+        }
+        const fieldDefinition = fieldMap[fieldName];
+        fieldResolvers[fieldName] = {
+            subscribe: fieldDefinition.subscribe,
+            resolve: fieldDefinition.resolve,
+        };
+    }
+    if ('resolveType' in objectType) {
+        fieldResolvers['__resolveType'] = objectType.resolveType;
+    }
+    if ('isTypeOf' in objectType) {
+        fieldResolvers['__isTypeOf'] = objectType.isTypeOf;
+    }
+    return fieldResolvers;
+}
+
+function extractResolversFromSchema(schema, options) {
+    let selectedTypeNames;
+    const resolvers = {};
+    const typeMap = schema.getTypeMap();
+    if (options && options.selectedTypeDefs) {
+        const invalidSchema = graphql.buildASTSchema(options.selectedTypeDefs);
+        selectedTypeNames = Object.keys(invalidSchema.getTypeMap());
+    }
+    for (const typeName in typeMap) {
+        if (!typeName.startsWith('__')) {
+            const typeDef = typeMap[typeName];
+            if (selectedTypeNames && !selectedTypeNames.includes(typeName)) {
+                continue;
+            }
+            if (graphql.isScalarType(typeDef)) {
+                resolvers[typeName] = typeDef;
+            }
+            else if (graphql.isObjectType(typeDef) || graphql.isInterfaceType(typeDef)) {
+                resolvers[typeName] = extractFieldResolversFromObjectType(typeDef, {
+                    selectedTypeDefs: options && options.selectedTypeDefs,
+                });
+            }
+            else if (graphql.isEnumType(typeDef)) {
+                const enumValues = typeDef.getValues();
+                resolvers[typeName] = {};
+                for (const { name, value } of enumValues) {
+                    resolvers[typeName][name] = value;
+                }
+            }
+            else if (graphql.isUnionType(typeDef)) {
+                resolvers[typeName] = {
+                    __resolveType: typeDef.resolveType,
+                };
+            }
+        }
+    }
+    return resolvers;
+}
+
+exports.SchemaError = SchemaError;
 exports.asArray = asArray;
@@ -1017,4 +1187,6 @@ exports.buildOperationNodeForField = buildOperationNodeForField;
 exports.composeResolvers = composeResolvers;
+exports.createNamedStub = createNamedStub;
 exports.createSchemaDefinition = createSchemaDefinition;
 exports.debugLog = debugLog;
+exports.each = each;
 exports.extractFieldResolversFromObjectType = extractFieldResolversFromObjectType;
@@ -1025,6 +1197,8 @@ exports.extractResolversFromSchema = extractResolversFromSchema;
 exports.flattenArray = flattenArray;
+exports.forEachDefaultValue = forEachDefaultValue;
+exports.forEachField = forEachField;
+exports.getBuiltInForStub = getBuiltInForStub;
 exports.getDirectives = getDirectives;
 exports.getFieldsWithDirectives = getFieldsWithDirectives;
 exports.getImplementingTypes = getImplementingTypes;
-exports.getSchemaDirectiveFromDirectiveResolver = getSchemaDirectiveFromDirectiveResolver;
 exports.getUserTypesFromSchema = getUserTypesFromSchema;
@@ -1034,9 +1208,16 @@ exports.isDocumentString = isDocumentString;
 exports.isNotEqual = isNotEqual;
+exports.isStub = isStub;
 exports.isValidPath = isValidPath;
+exports.mergeDeep = mergeDeep;
 exports.nodeToString = nodeToString;
 exports.parseGraphQLJSON = parseGraphQLJSON;
 exports.parseGraphQLSDL = parseGraphQLSDL;
+exports.parseInputValue = parseInputValue;
+exports.parseInputValueLiteral = parseInputValueLiteral;
 exports.printSchemaWithDirectives = printSchemaWithDirectives;
 exports.resolveBuiltinModule = resolveBuiltinModule;
 exports.resolveBuiltinModuleSync = resolveBuiltinModuleSync;
+exports.serializeInputValue = serializeInputValue;
+exports.transformInputValue = transformInputValue;
+exports.updateEachKey = updateEachKey;
 exports.validateGraphQlDocuments = validateGraphQlDocuments;

index.d.ts

 export * from './loaders';
 export * from './helpers';
 export * from './debug-log';
-export * from './extract-field-resolvers-from-object-type';
-export * from './extract-resolvers-from-schema';
 export * from './fix-windows-path';
@@ -11,3 +9,2 @@ export * from './flatten-array';
 export * from './get-implementing-types';
-export * from './get-schema-directive-from-directive-resolver';
 export * from './print-schema-with-directives';
@@ -23,2 +20,9 @@ export * from './get-fields-with-directives';
 export * from './build-operation-for-field';
+export * from './schema-error';
+export * from './iterate';
+export * from './merge';
+export * from './stub';
+export * from './transport-input';
+export * from './extract-field-resolvers-from-object-type';
+export * from './extract-resolvers-from-schema';
 export * from './types';

index.esm.js

@@ -1,5 +0,5 @@
-import { parse, buildASTSchema, isScalarType, isObjectType, isInterfaceType, isEnumType, isUnionType, getDirectiveValues, Kind, defaultFieldResolver, isSpecifiedScalarType, isIntrospectionType, print, printType, specifiedRules, validate, buildSchema, buildClientSchema, Source, isListType, isNonNullType, getNamedType } from 'graphql';
-import { SchemaDirectiveVisitor } from 'graphql-tools-fork';
+import { parse, getDirectiveValues, Kind, isObjectType, isScalarType, isSpecifiedScalarType, isIntrospectionType, print, printType, specifiedRules, validate, buildSchema, buildClientSchema, Source, isListType, isNonNullType, getNamedType, isUnionType, isInterfaceType, isInputObjectType, GraphQLString, GraphQLID, GraphQLBoolean, GraphQLFloat, GraphQLInt, GraphQLObjectType, GraphQLInterfaceType, GraphQLInputObjectType, getNullableType, isLeafType, buildASTSchema, isEnumType } from 'graphql';
 import AggregateError from 'aggregate-error';
-import { get, set } from 'lodash';
+import get from 'lodash.get';
+import set from 'lodash.set';
 import { camelCase } from 'camel-case';
@@ -123,73 +123,2 @@
 
-function extractFieldResolversFromObjectType(objectType, options) {
-    const fieldResolvers = {};
-    const fieldMap = objectType.getFields();
-    let selectedFieldNames;
-    if (options && options.selectedTypeDefs) {
-        const invalidSchema = buildASTSchema(options.selectedTypeDefs);
-        const typeMap = invalidSchema.getTypeMap();
-        if (!(objectType.name in typeMap)) {
-            return {};
-        }
-        const selectedObjectType = typeMap[objectType.name];
-        selectedFieldNames = Object.keys(selectedObjectType.getFields());
-    }
-    for (const fieldName in fieldMap) {
-        if (selectedFieldNames && !selectedFieldNames.includes(fieldName)) {
-            continue;
-        }
-        const fieldDefinition = fieldMap[fieldName];
-        fieldResolvers[fieldName] = {
-            subscribe: fieldDefinition.subscribe,
-            resolve: fieldDefinition.resolve,
-        };
-    }
-    if ('resolveType' in objectType) {
-        fieldResolvers['__resolveType'] = objectType.resolveType;
-    }
-    if ('isTypeOf' in objectType) {
-        fieldResolvers['__isTypeOf'] = objectType.isTypeOf;
-    }
-    return fieldResolvers;
-}
-
-function extractResolversFromSchema(schema, options) {
-    let selectedTypeNames;
-    const resolvers = {};
-    const typeMap = schema.getTypeMap();
-    if (options && options.selectedTypeDefs) {
-        const invalidSchema = buildASTSchema(options.selectedTypeDefs);
-        selectedTypeNames = Object.keys(invalidSchema.getTypeMap());
-    }
-    for (const typeName in typeMap) {
-        if (!typeName.startsWith('__')) {
-            const typeDef = typeMap[typeName];
-            if (selectedTypeNames && !selectedTypeNames.includes(typeName)) {
-                continue;
-            }
-            if (isScalarType(typeDef)) {
-                resolvers[typeName] = typeDef;
-            }
-            else if (isObjectType(typeDef) || isInterfaceType(typeDef)) {
-                resolvers[typeName] = extractFieldResolversFromObjectType(typeDef, {
-                    selectedTypeDefs: options && options.selectedTypeDefs,
-                });
-            }
-            else if (isEnumType(typeDef)) {
-                const enumValues = typeDef.getValues();
-                resolvers[typeName] = {};
-                for (const { name, value } of enumValues) {
-                    resolvers[typeName][name] = value;
-                }
-            }
-            else if (isUnionType(typeDef)) {
-                resolvers[typeName] = {
-                    __resolveType: typeDef.resolveType,
-                };
-            }
-        }
-    }
-    return resolvers;
-}
-
 const fixWindowsPath = (path) => path.replace(/\\/g, '/');
@@ -273,16 +202,2 @@
 
-function getSchemaDirectiveFromDirectiveResolver(directiveResolver) {
-    return class extends SchemaDirectiveVisitor {
-        visitFieldDefinition(field) {
-            const resolver = directiveResolver;
-            const originalResolver = field.resolve || defaultFieldResolver;
-            const directiveArgs = this.args;
-            field.resolve = (...args) => {
-                const [source /* original args */, , context, info] = args;
-                return resolver(async () => originalResolver.apply(field, args), source, directiveArgs, context, info);
-            };
-        }
-    };
-}
-
 function createSchemaDefinition(def, config) {
@@ -982,2 +897,256 @@ const schemaRoot = {};
 
-export { asArray, buildOperationNodeForField, chainFunctions, checkValidationErrors, compareNodes, compareStrings, composeResolvers, createSchemaDefinition, debugLog, extractFieldResolversFromObjectType, extractResolversFromSchema, fixSchemaAst, fixWindowsPath, flattenArray, getDirectives, getFieldsWithDirectives, getImplementingTypes, getSchemaDirectiveFromDirectiveResolver, getUserTypesFromSchema, isDocumentString, isEqual, isNotEqual, isValidPath, nodeToString, parseGraphQLJSON, parseGraphQLSDL, printSchemaWithDirectives, resolveBuiltinModule, resolveBuiltinModuleSync, validateGraphQlDocuments };
+// @schemaDefinition: A GraphQL type schema in shorthand
+// @resolvers: Definitions for resolvers to be merged with schema
+class SchemaError extends Error {
+    constructor(message) {
+        super(message);
+        this.message = message;
+        Error.captureStackTrace(this, this.constructor);
+    }
+}
+
+function forEachField(schema, fn) {
+    const typeMap = schema.getTypeMap();
+    Object.keys(typeMap).forEach((typeName) => {
+        const type = typeMap[typeName];
+        // TODO: maybe have an option to include these?
+        if (!getNamedType(type).name.startsWith('__') && isObjectType(type)) {
+            const fields = type.getFields();
+            Object.keys(fields).forEach((fieldName) => {
+                const field = fields[fieldName];
+                fn(field, typeName, fieldName);
+            });
+        }
+    });
+}
+function forEachDefaultValue(schema, fn) {
+    const typeMap = schema.getTypeMap();
+    Object.keys(typeMap).forEach((typeName) => {
+        const type = typeMap[typeName];
+        if (!getNamedType(type).name.startsWith('__')) {
+            if (isObjectType(type)) {
+                const fields = type.getFields();
+                Object.keys(fields).forEach((fieldName) => {
+                    const field = fields[fieldName];
+                    field.args.forEach((arg) => {
+                        arg.defaultValue = fn(arg.type, arg.defaultValue);
+                    });
+                });
+            }
+            else if (isInputObjectType(type)) {
+                const fields = type.getFields();
+                Object.keys(fields).forEach((fieldName) => {
+                    const field = fields[fieldName];
+                    field.defaultValue = fn(field.type, field.defaultValue);
+                });
+            }
+        }
+    });
+}
+// A more powerful version of each that has the ability to replace or remove
+// array or object keys.
+function updateEachKey(arrayOrObject, 
+// The callback can return nothing to leave the key untouched, null to remove
+// the key from the array or object, or a non-null V to replace the value.
+updater) {
+    let deletedCount = 0;
+    Object.keys(arrayOrObject).forEach((key) => {
+        const result = updater(arrayOrObject[key], key);
+        if (typeof result === 'undefined') {
+            return;
+        }
+        if (result === null) {
+            delete arrayOrObject[key];
+            deletedCount++;
+            return;
+        }
+        arrayOrObject[key] = result;
+    });
+    if (deletedCount > 0 && Array.isArray(arrayOrObject)) {
+        // Remove any holes from the array due to deleted elements.
+        arrayOrObject.splice(0).forEach((elem) => {
+            arrayOrObject.push(elem);
+        });
+    }
+}
+function each(arrayOrObject, callback) {
+    Object.keys(arrayOrObject).forEach((key) => {
+        callback(arrayOrObject[key], key);
+    });
+}
+
+function mergeDeep(target, ...sources) {
+    const output = {
+        ...target,
+    };
+    sources.forEach((source) => {
+        if (isObject(target) && isObject(source)) {
+            Object.keys(source).forEach((key) => {
+                if (isObject(source[key])) {
+                    if (!(key in target)) {
+                        Object.assign(output, { [key]: source[key] });
+                    }
+                    else {
+                        output[key] = mergeDeep(target[key], source[key]);
+                    }
+                }
+                else {
+                    Object.assign(output, { [key]: source[key] });
+                }
+            });
+        }
+    });
+    return output;
+}
+function isObject(item) {
+    return item && typeof item === 'object' && !Array.isArray(item);
+}
+
+function createNamedStub(name, type) {
+    let constructor;
+    if (type === 'object') {
+        constructor = GraphQLObjectType;
+    }
+    else if (type === 'interface') {
+        constructor = GraphQLInterfaceType;
+    }
+    else {
+        constructor = GraphQLInputObjectType;
+    }
+    return new constructor({
+        name,
+        fields: {
+            __fake: {
+                type: GraphQLString,
+            },
+        },
+    });
+}
+function isStub(type) {
+    if (isObjectType(type) || isInterfaceType(type) || isInputObjectType(type)) {
+        const fields = type.getFields();
+        const fieldNames = Object.keys(fields);
+        return fieldNames.length === 1 && fields[fieldNames[0]].name === '__fake';
+    }
+    return false;
+}
+function getBuiltInForStub(type) {
+    switch (type.name) {
+        case GraphQLInt.name:
+            return GraphQLInt;
+        case GraphQLFloat.name:
+            return GraphQLFloat;
+        case GraphQLString.name:
+            return GraphQLString;
+        case GraphQLBoolean.name:
+            return GraphQLBoolean;
+        case GraphQLID.name:
+            return GraphQLID;
+        default:
+            return type;
+    }
+}
+
+function transformInputValue(type, value, transformer) {
+    if (value == null) {
+        return value;
+    }
+    const nullableType = getNullableType(type);
+    if (isLeafType(nullableType)) {
+        return transformer(nullableType, value);
+    }
+    else if (isListType(nullableType)) {
+        return value.map((listMember) => transformInputValue(nullableType.ofType, listMember, transformer));
+    }
+    else if (isInputObjectType(nullableType)) {
+        const fields = nullableType.getFields();
+        const newValue = {};
+        Object.keys(value).forEach((key) => {
+            newValue[key] = transformInputValue(fields[key].type, value[key], transformer);
+        });
+        return newValue;
+    }
+    // unreachable, no other possible return value
+}
+function serializeInputValue(type, value) {
+    return transformInputValue(type, value, (t, v) => t.serialize(v));
+}
+function parseInputValue(type, value) {
+    return transformInputValue(type, value, (t, v) => t.parseValue(v));
+}
+function parseInputValueLiteral(type, value) {
+    return transformInputValue(type, value, (t, v) => t.parseLiteral(v, {}));
+}
+
+function extractFieldResolversFromObjectType(objectType, options) {
+    const fieldResolvers = {};
+    const fieldMap = objectType.getFields();
+    let selectedFieldNames;
+    if (options && options.selectedTypeDefs) {
+        const invalidSchema = buildASTSchema(options.selectedTypeDefs);
+        const typeMap = invalidSchema.getTypeMap();
+        if (!(objectType.name in typeMap)) {
+            return {};
+        }
+        const selectedObjectType = typeMap[objectType.name];
+        selectedFieldNames = Object.keys(selectedObjectType.getFields());
+    }
+    for (const fieldName in fieldMap) {
+        if (selectedFieldNames && !selectedFieldNames.includes(fieldName)) {
+            continue;
+        }
+        const fieldDefinition = fieldMap[fieldName];
+        fieldResolvers[fieldName] = {
+            subscribe: fieldDefinition.subscribe,
+            resolve: fieldDefinition.resolve,
+        };
+    }
+    if ('resolveType' in objectType) {
+        fieldResolvers['__resolveType'] = objectType.resolveType;
+    }
+    if ('isTypeOf' in objectType) {
+        fieldResolvers['__isTypeOf'] = objectType.isTypeOf;
+    }
+    return fieldResolvers;
+}
+
+function extractResolversFromSchema(schema, options) {
+    let selectedTypeNames;
+    const resolvers = {};
+    const typeMap = schema.getTypeMap();
+    if (options && options.selectedTypeDefs) {
+        const invalidSchema = buildASTSchema(options.selectedTypeDefs);
+        selectedTypeNames = Object.keys(invalidSchema.getTypeMap());
+    }
+    for (const typeName in typeMap) {
+        if (!typeName.startsWith('__')) {
+            const typeDef = typeMap[typeName];
+            if (selectedTypeNames && !selectedTypeNames.includes(typeName)) {
+                continue;
+            }
+            if (isScalarType(typeDef)) {
+                resolvers[typeName] = typeDef;
+            }
+            else if (isObjectType(typeDef) || isInterfaceType(typeDef)) {
+                resolvers[typeName] = extractFieldResolversFromObjectType(typeDef, {
+                    selectedTypeDefs: options && options.selectedTypeDefs,
+                });
+            }
+            else if (isEnumType(typeDef)) {
+                const enumValues = typeDef.getValues();
+                resolvers[typeName] = {};
+                for (const { name, value } of enumValues) {
+                    resolvers[typeName][name] = value;
+                }
+            }
+            else if (isUnionType(typeDef)) {
+                resolvers[typeName] = {
+                    __resolveType: typeDef.resolveType,
+                };
+            }
+        }
+    }
+    return resolvers;
+}
+
+export { SchemaError, asArray, buildOperationNodeForField, chainFunctions, checkValidationErrors, compareNodes, compareStrings, composeResolvers, createNamedStub, createSchemaDefinition, debugLog, each, extractFieldResolversFromObjectType, extractResolversFromSchema, fixSchemaAst, fixWindowsPath, flattenArray, forEachDefaultValue, forEachField, getBuiltInForStub, getDirectives, getFieldsWithDirectives, getImplementingTypes, getUserTypesFromSchema, isDocumentString, isEqual, isNotEqual, isStub, isValidPath, mergeDeep, nodeToString, parseGraphQLJSON, parseGraphQLSDL, parseInputValue, parseInputValueLiteral, printSchemaWithDirectives, resolveBuiltinModule, resolveBuiltinModuleSync, serializeInputValue, transformInputValue, updateEachKey, validateGraphQlDocuments };

package.json

 {
   "name": "@graphql-toolkit/common",
-  "version": "0.10.3-alpha-475ea3f.3+475ea3f",
+  "version": "0.10.3-alpha-87df00e.5+87df00e",
   "description": "Common package containting utils and types for GraphQL Toolkit",
@@ -18,8 +18,9 @@ "peerDependencies": {
   "dependencies": {
+    "@graphql-toolkit/types": "0.10.3-alpha-87df00e.5+87df00e",
     "aggregate-error": "3.0.1",
     "camel-case": "4.1.1",
-    "graphql-tools-fork": "9.0.1",
-    "lodash": "4.17.15"
+    "lodash.get": "4.4.2",
+    "lodash.set": "4.3.2"
   },
   "sideEffects": false
 }

resolvers-composition.d.ts

@@ -1,2 +0,2 @@
-import { IResolvers, IFieldResolver } from 'graphql-tools-fork';
+import { IResolvers, IFieldResolver } from '@graphql-toolkit/types';
 export declare type ResolversComposition<Resolver extends IFieldResolver<any, any> = IFieldResolver<any, any>> = (next: Resolver) => Resolver;
@@ -3,0 +3,0 @@ export declare type ResolversComposerMapping<Resolvers extends IResolvers = IResolvers> = {

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Manifest confusion

Supply chain risk

This package has inconsistent metadata. This could be malicious or caused by an error when publishing the package.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Manifest confusion

Supply chain risk

This package has inconsistent metadata. This could be malicious or caused by an error when publishing the package.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

98359

increased by16.44%

Number of package files

30

increased by15.38%

Lines of code

2540

increased by17.05%

Worsened metrics

Dependency count

6

increased by20%

Dependency changes

• + Added@graphql-toolkit/types@0.10.3-alpha-87df00e.5+87df00e

• + Addedlodash.get@4.4.2

• + Addedlodash.set@4.3.2

• + Addedlodash.get@4.4.2(transitive)

• + Addedlodash.set@4.3.2(transitive)

• - Removedgraphql-tools-fork@9.0.1

• - Removedlodash@4.17.15

• - Removed@wry/equality@0.1.11(transitive)

• - Removedapollo-link@1.2.14(transitive)

• - Removedapollo-link-http-common@0.2.16(transitive)

• - Removedapollo-utilities@1.3.4(transitive)

• - Removedasynckit@0.4.0(transitive)

• - Removedcombined-stream@1.0.8(transitive)

• - Removeddelayed-stream@1.0.0(transitive)

• - Removeddeprecated-decorator@0.1.6(transitive)

• - Removedextract-files@7.0.0(transitive)

• - Removedfast-json-stable-stringify@2.1.0(transitive)

• - Removedform-data@3.0.1(transitive)

• - Removedgraphql-tools-fork@9.0.1(transitive)

• - Removediterall@1.3.0(transitive)

• - Removedlodash@4.17.15(transitive)

• - Removedmime-db@1.52.0(transitive)

• - Removedmime-types@2.1.35(transitive)

• - Removednode-fetch@2.7.0(transitive)

• - Removedtr46@0.0.3(transitive)

• - Removedts-invariant@0.4.4(transitive)

• - Removeduuid@7.0.3(transitive)

• - Removedwebidl-conversions@3.0.1(transitive)

• - Removedwhatwg-url@5.0.0(transitive)

• - Removedzen-observable@0.8.15(transitive)

• - Removedzen-observable-ts@0.8.21(transitive)