PHP WebShell
Текущая директория: /usr/lib/node_modules/bitgo/node_modules/@expo/cli/node_modules/graphql/utilities
Просмотр файла: buildClientSchema.mjs
import objectValues from "../polyfills/objectValues.mjs";
import inspect from "../jsutils/inspect.mjs";
import devAssert from "../jsutils/devAssert.mjs";
import keyValMap from "../jsutils/keyValMap.mjs";
import isObjectLike from "../jsutils/isObjectLike.mjs";
import { parseValue } from "../language/parser.mjs";
import { GraphQLSchema } from "../type/schema.mjs";
import { GraphQLDirective } from "../type/directives.mjs";
import { specifiedScalarTypes } from "../type/scalars.mjs";
import { introspectionTypes, TypeKind } from "../type/introspection.mjs";
import { isInputType, isOutputType, GraphQLList, GraphQLNonNull, GraphQLScalarType, GraphQLObjectType, GraphQLInterfaceType, GraphQLUnionType, GraphQLEnumType, GraphQLInputObjectType, assertNullableType, assertObjectType, assertInterfaceType } from "../type/definition.mjs";
import { valueFromAST } from "./valueFromAST.mjs";
/**
* Build a GraphQLSchema for use by client tools.
*
* Given the result of a client running the introspection query, creates and
* returns a GraphQLSchema instance which can be then used with all graphql-js
* tools, but cannot be used to execute a query, as introspection does not
* represent the "resolver", "parse" or "serialize" functions or any other
* server-internal mechanisms.
*
* This function expects a complete introspection result. Don't forget to check
* the "errors" field of a server response before calling this function.
*/
export function buildClientSchema(introspection, options) {
isObjectLike(introspection) && isObjectLike(introspection.__schema) || devAssert(0, "Invalid or incomplete introspection result. Ensure that you are passing \"data\" property of introspection response and no \"errors\" was returned alongside: ".concat(inspect(introspection), ".")); // Get the schema from the introspection result.
var schemaIntrospection = introspection.__schema; // Iterate through all types, getting the type definition for each.
var typeMap = keyValMap(schemaIntrospection.types, function (typeIntrospection) {
return typeIntrospection.name;
}, function (typeIntrospection) {
return buildType(typeIntrospection);
}); // Include standard types only if they are used.
for (var _i2 = 0, _ref2 = [].concat(specifiedScalarTypes, introspectionTypes); _i2 < _ref2.length; _i2++) {
var stdType = _ref2[_i2];
if (typeMap[stdType.name]) {
typeMap[stdType.name] = stdType;
}
} // Get the root Query, Mutation, and Subscription types.
var queryType = schemaIntrospection.queryType ? getObjectType(schemaIntrospection.queryType) : null;
var mutationType = schemaIntrospection.mutationType ? getObjectType(schemaIntrospection.mutationType) : null;
var subscriptionType = schemaIntrospection.subscriptionType ? getObjectType(schemaIntrospection.subscriptionType) : null; // Get the directives supported by Introspection, assuming empty-set if
// directives were not queried for.
var directives = schemaIntrospection.directives ? schemaIntrospection.directives.map(buildDirective) : []; // Then produce and return a Schema with these types.
return new GraphQLSchema({
description: schemaIntrospection.description,
query: queryType,
mutation: mutationType,
subscription: subscriptionType,
types: objectValues(typeMap),
directives: directives,
assumeValid: options === null || options === void 0 ? void 0 : options.assumeValid
}); // Given a type reference in introspection, return the GraphQLType instance.
// preferring cached instances before building new instances.
function getType(typeRef) {
if (typeRef.kind === TypeKind.LIST) {
var itemRef = typeRef.ofType;
if (!itemRef) {
throw new Error('Decorated type deeper than introspection query.');
}
return new GraphQLList(getType(itemRef));
}
if (typeRef.kind === TypeKind.NON_NULL) {
var nullableRef = typeRef.ofType;
if (!nullableRef) {
throw new Error('Decorated type deeper than introspection query.');
}
var nullableType = getType(nullableRef);
return new GraphQLNonNull(assertNullableType(nullableType));
}
return getNamedType(typeRef);
}
function getNamedType(typeRef) {
var typeName = typeRef.name;
if (!typeName) {
throw new Error("Unknown type reference: ".concat(inspect(typeRef), "."));
}
var type = typeMap[typeName];
if (!type) {
throw new Error("Invalid or incomplete schema, unknown type: ".concat(typeName, ". Ensure that a full introspection query is used in order to build a client schema."));
}
return type;
}
function getObjectType(typeRef) {
return assertObjectType(getNamedType(typeRef));
}
function getInterfaceType(typeRef) {
return assertInterfaceType(getNamedType(typeRef));
} // Given a type's introspection result, construct the correct
// GraphQLType instance.
function buildType(type) {
if (type != null && type.name != null && type.kind != null) {
switch (type.kind) {
case TypeKind.SCALAR:
return buildScalarDef(type);
case TypeKind.OBJECT:
return buildObjectDef(type);
case TypeKind.INTERFACE:
return buildInterfaceDef(type);
case TypeKind.UNION:
return buildUnionDef(type);
case TypeKind.ENUM:
return buildEnumDef(type);
case TypeKind.INPUT_OBJECT:
return buildInputObjectDef(type);
}
}
var typeStr = inspect(type);
throw new Error("Invalid or incomplete introspection result. Ensure that a full introspection query is used in order to build a client schema: ".concat(typeStr, "."));
}
function buildScalarDef(scalarIntrospection) {
return new GraphQLScalarType({
name: scalarIntrospection.name,
description: scalarIntrospection.description,
specifiedByUrl: scalarIntrospection.specifiedByUrl
});
}
function buildImplementationsList(implementingIntrospection) {
// TODO: Temporary workaround until GraphQL ecosystem will fully support
// 'interfaces' on interface types.
if (implementingIntrospection.interfaces === null && implementingIntrospection.kind === TypeKind.INTERFACE) {
return [];
}
if (!implementingIntrospection.interfaces) {
var implementingIntrospectionStr = inspect(implementingIntrospection);
throw new Error("Introspection result missing interfaces: ".concat(implementingIntrospectionStr, "."));
}
return implementingIntrospection.interfaces.map(getInterfaceType);
}
function buildObjectDef(objectIntrospection) {
return new GraphQLObjectType({
name: objectIntrospection.name,
description: objectIntrospection.description,
interfaces: function interfaces() {
return buildImplementationsList(objectIntrospection);
},
fields: function fields() {
return buildFieldDefMap(objectIntrospection);
}
});
}
function buildInterfaceDef(interfaceIntrospection) {
return new GraphQLInterfaceType({
name: interfaceIntrospection.name,
description: interfaceIntrospection.description,
interfaces: function interfaces() {
return buildImplementationsList(interfaceIntrospection);
},
fields: function fields() {
return buildFieldDefMap(interfaceIntrospection);
}
});
}
function buildUnionDef(unionIntrospection) {
if (!unionIntrospection.possibleTypes) {
var unionIntrospectionStr = inspect(unionIntrospection);
throw new Error("Introspection result missing possibleTypes: ".concat(unionIntrospectionStr, "."));
}
return new GraphQLUnionType({
name: unionIntrospection.name,
description: unionIntrospection.description,
types: function types() {
return unionIntrospection.possibleTypes.map(getObjectType);
}
});
}
function buildEnumDef(enumIntrospection) {
if (!enumIntrospection.enumValues) {
var enumIntrospectionStr = inspect(enumIntrospection);
throw new Error("Introspection result missing enumValues: ".concat(enumIntrospectionStr, "."));
}
return new GraphQLEnumType({
name: enumIntrospection.name,
description: enumIntrospection.description,
values: keyValMap(enumIntrospection.enumValues, function (valueIntrospection) {
return valueIntrospection.name;
}, function (valueIntrospection) {
return {
description: valueIntrospection.description,
deprecationReason: valueIntrospection.deprecationReason
};
})
});
}
function buildInputObjectDef(inputObjectIntrospection) {
if (!inputObjectIntrospection.inputFields) {
var inputObjectIntrospectionStr = inspect(inputObjectIntrospection);
throw new Error("Introspection result missing inputFields: ".concat(inputObjectIntrospectionStr, "."));
}
return new GraphQLInputObjectType({
name: inputObjectIntrospection.name,
description: inputObjectIntrospection.description,
fields: function fields() {
return buildInputValueDefMap(inputObjectIntrospection.inputFields);
}
});
}
function buildFieldDefMap(typeIntrospection) {
if (!typeIntrospection.fields) {
throw new Error("Introspection result missing fields: ".concat(inspect(typeIntrospection), "."));
}
return keyValMap(typeIntrospection.fields, function (fieldIntrospection) {
return fieldIntrospection.name;
}, buildField);
}
function buildField(fieldIntrospection) {
var type = getType(fieldIntrospection.type);
if (!isOutputType(type)) {
var typeStr = inspect(type);
throw new Error("Introspection must provide output type for fields, but received: ".concat(typeStr, "."));
}
if (!fieldIntrospection.args) {
var fieldIntrospectionStr = inspect(fieldIntrospection);
throw new Error("Introspection result missing field args: ".concat(fieldIntrospectionStr, "."));
}
return {
description: fieldIntrospection.description,
deprecationReason: fieldIntrospection.deprecationReason,
type: type,
args: buildInputValueDefMap(fieldIntrospection.args)
};
}
function buildInputValueDefMap(inputValueIntrospections) {
return keyValMap(inputValueIntrospections, function (inputValue) {
return inputValue.name;
}, buildInputValue);
}
function buildInputValue(inputValueIntrospection) {
var type = getType(inputValueIntrospection.type);
if (!isInputType(type)) {
var typeStr = inspect(type);
throw new Error("Introspection must provide input type for arguments, but received: ".concat(typeStr, "."));
}
var defaultValue = inputValueIntrospection.defaultValue != null ? valueFromAST(parseValue(inputValueIntrospection.defaultValue), type) : undefined;
return {
description: inputValueIntrospection.description,
type: type,
defaultValue: defaultValue,
deprecationReason: inputValueIntrospection.deprecationReason
};
}
function buildDirective(directiveIntrospection) {
if (!directiveIntrospection.args) {
var directiveIntrospectionStr = inspect(directiveIntrospection);
throw new Error("Introspection result missing directive args: ".concat(directiveIntrospectionStr, "."));
}
if (!directiveIntrospection.locations) {
var _directiveIntrospectionStr = inspect(directiveIntrospection);
throw new Error("Introspection result missing directive locations: ".concat(_directiveIntrospectionStr, "."));
}
return new GraphQLDirective({
name: directiveIntrospection.name,
description: directiveIntrospection.description,
isRepeatable: directiveIntrospection.isRepeatable,
locations: directiveIntrospection.locations.slice(),
args: buildInputValueDefMap(directiveIntrospection.args)
});
}
}
Выполнить команду
Для локальной разработки. Не используйте в интернете!