@graphql-toolkit/common
Advanced tools
Comparing version 0.10.3-alpha-0a56f31.6 to 0.10.3-alpha-0c0c742.6
import { GraphQLSchema, DocumentNode } from 'graphql'; | ||
import { IResolvers } from '@graphql-toolkit/types'; | ||
import { IResolvers } from 'graphql-tools-fork'; | ||
export interface ExtractResolversFromSchemaOptions { | ||
@@ -4,0 +4,0 @@ selectedTypeDefs?: DocumentNode; |
361
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 get = _interopDefault(require('lodash.get')); | ||
const set = _interopDefault(require('lodash.set')); | ||
const lodash = require('lodash'); | ||
const camelCase = require('camel-case'); | ||
@@ -149,2 +149,73 @@ | ||
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, '/'); | ||
@@ -228,2 +299,16 @@ | ||
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) { | ||
@@ -446,4 +531,4 @@ const schemaRoot = {}; | ||
Object.keys(mappingResult).forEach((path) => { | ||
const fns = chainFunctions([...asArray(mappingResult[path]), () => get(resolvers, path)]); | ||
set(resolvers, path, fns()); | ||
const fns = chainFunctions([...asArray(mappingResult[path]), () => lodash.get(resolvers, path)]); | ||
lodash.set(resolvers, path, fns()); | ||
}); | ||
@@ -924,257 +1009,2 @@ 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; | ||
@@ -1187,6 +1017,4 @@ exports.buildOperationNodeForField = buildOperationNodeForField; | ||
exports.composeResolvers = composeResolvers; | ||
exports.createNamedStub = createNamedStub; | ||
exports.createSchemaDefinition = createSchemaDefinition; | ||
exports.debugLog = debugLog; | ||
exports.each = each; | ||
exports.extractFieldResolversFromObjectType = extractFieldResolversFromObjectType; | ||
@@ -1197,8 +1025,6 @@ 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; | ||
@@ -1208,16 +1034,9 @@ 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; |
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'; | ||
@@ -9,2 +11,3 @@ export * from './flatten-array'; | ||
export * from './get-implementing-types'; | ||
export * from './get-schema-directive-from-directive-resolver'; | ||
export * from './print-schema-with-directives'; | ||
@@ -20,9 +23,2 @@ 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'; |
347
index.esm.js
@@ -1,5 +0,5 @@ | ||
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 { 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 AggregateError from 'aggregate-error'; | ||
import get from 'lodash.get'; | ||
import set from 'lodash.set'; | ||
import { get, set } from 'lodash'; | ||
import { camelCase } from 'camel-case'; | ||
@@ -123,2 +123,73 @@ | ||
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, '/'); | ||
@@ -202,2 +273,16 @@ | ||
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) { | ||
@@ -897,256 +982,2 @@ const schemaRoot = {}; | ||
// @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 }; | ||
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 }; |
{ | ||
"name": "@graphql-toolkit/common", | ||
"version": "0.10.3-alpha-0a56f31.6+0a56f31", | ||
"version": "0.10.3-alpha-0c0c742.6+0c0c742", | ||
"description": "Common package containting utils and types for GraphQL Toolkit", | ||
@@ -18,9 +18,8 @@ "peerDependencies": { | ||
"dependencies": { | ||
"@graphql-toolkit/types": "0.10.3-alpha-0a56f31.6+0a56f31", | ||
"aggregate-error": "3.0.1", | ||
"camel-case": "4.1.1", | ||
"lodash.get": "4.4.2", | ||
"lodash.set": "4.3.2" | ||
"graphql-tools-fork": "9.0.1", | ||
"lodash": "4.17.15" | ||
}, | ||
"sideEffects": false | ||
} |
@@ -1,2 +0,2 @@ | ||
import { IResolvers, IFieldResolver } from '@graphql-toolkit/types'; | ||
import { IResolvers, IFieldResolver } from 'graphql-tools-fork'; | ||
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> = { |
License Policy Violation
LicenseThis 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 riskThis package has inconsistent metadata. This could be malicious or caused by an error when publishing the package.
Found 1 instance in 1 package
License Policy Violation
LicenseThis 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 riskThis package has inconsistent metadata. This could be malicious or caused by an error when publishing the package.
Found 1 instance in 1 package
5
84472
26
2170
+ Addedgraphql-tools-fork@9.0.1
+ Addedlodash@4.17.15
+ Added@wry/equality@0.1.11(transitive)
+ Addedapollo-link@1.2.14(transitive)
+ Addedapollo-link-http-common@0.2.16(transitive)
+ Addedapollo-utilities@1.3.4(transitive)
+ Addedasynckit@0.4.0(transitive)
+ Addedcombined-stream@1.0.8(transitive)
+ Addeddelayed-stream@1.0.0(transitive)
+ Addeddeprecated-decorator@0.1.6(transitive)
+ Addedextract-files@7.0.0(transitive)
+ Addedfast-json-stable-stringify@2.1.0(transitive)
+ Addedform-data@3.0.1(transitive)
+ Addedgraphql-tools-fork@9.0.1(transitive)
+ Addediterall@1.3.0(transitive)
+ Addedlodash@4.17.15(transitive)
+ Addedmime-db@1.52.0(transitive)
+ Addedmime-types@2.1.35(transitive)
+ Addednode-fetch@2.7.0(transitive)
+ Addedtr46@0.0.3(transitive)
+ Addedts-invariant@0.4.4(transitive)
+ Addeduuid@7.0.3(transitive)
+ Addedwebidl-conversions@3.0.1(transitive)
+ Addedwhatwg-url@5.0.0(transitive)
+ Addedzen-observable@0.8.15(transitive)
+ Addedzen-observable-ts@0.8.21(transitive)
- Removed@graphql-toolkit/types@0.10.3-alpha-0a56f31.6+0a56f31
- Removedlodash.get@4.4.2
- Removedlodash.set@4.3.2
- Removedlodash.get@4.4.2(transitive)
- Removedlodash.set@4.3.2(transitive)