graphql-codegen-core/dist/schema/transform-fields.js

GraphQL types and code generator based on schema

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var graphql_1 = require("graphql");
var object_map_to_array_1 = require("../utils/object-map-to-array");
var resolve_type_1 = require("./resolve-type");
var resolve_arguments_1 = require("./resolve-arguments");
var resolve_type_indicators_1 = require("./resolve-type-indicators");
var debugging_1 = require("../debugging");
var graphql_toolkit_1 = require("graphql-toolkit");
function resolveFields(schema, rawFields, _parent) {
    var fieldsArray = object_map_to_array_1.objectMapToArray(rawFields);
    return fieldsArray.map(function (item) {
        var type = resolve_type_1.resolveType(item.value.type);
        var resolvedArguments = resolve_arguments_1.resolveArguments(schema, item.value.args || []);
        var namedType = graphql_1.getNamedType(item.value.type);
        var indicators = resolve_type_indicators_1.resolveTypeIndicators(namedType);
        var directives = graphql_toolkit_1.getDirectives(schema, item.value);
        var defaultValue = null;
        var hasDefaultValue = false;
        if (isInputField(item.value)) {
            defaultValue = item.value.defaultValue;
            hasDefaultValue = defaultValue != null && typeof defaultValue !== 'undefined';
        }
        debugging_1.debugLog("[resolveFields] transformed field " + item.value.name + " of type " + type + ", resolved type is: ", type);
        return {
            name: item.value.name,
            description: item.value.description || '',
            arguments: resolvedArguments,
            type: type.name,
            fieldType: toFieldType(schema, namedType),
            raw: type.raw,
            isNullableArray: type.isNullableArray,
            isArray: type.isArray,
            dimensionOfArray: type.dimensionOfArray,
            isRequired: type.isRequired,
            hasArguments: resolvedArguments.length > 0,
            isEnum: indicators.isEnum,
            isScalar: indicators.isScalar,
            isInterface: indicators.isInterface,
            isUnion: indicators.isUnion,
            isInputType: indicators.isInputType,
            isType: indicators.isType,
            hasDefaultValue: hasDefaultValue,
            defaultValue: defaultValue,
            directives: directives,
            usesDirectives: Object.keys(directives).length > 0
        };
    });
}
exports.resolveFields = resolveFields;
function toFieldType(schema, type) {
    var typeMap = {
        Type: function () { return type instanceof graphql_1.GraphQLObjectType; },
        Scalar: function () { return type instanceof graphql_1.GraphQLScalarType; },
        Interface: function () { return type instanceof graphql_1.GraphQLInterfaceType; },
        Union: function () { return type instanceof graphql_1.GraphQLUnionType; },
        InputType: function () { return type instanceof graphql_1.GraphQLInputObjectType; },
        Enum: function () { return type instanceof graphql_1.GraphQLEnumType; },
        Query: function () { return schema.getQueryType() && schema.getQueryType().name === type.name; },
        Mutation: function () { return schema.getMutationType() && schema.getMutationType().name === type.name; },
        Subscription: function () {
            return schema.getSubscriptionType() && schema.getSubscriptionType().name === type.name;
        }
    };
    return Object.keys(typeMap).find(function (fieldType) { return typeMap[fieldType](); });
}
function isInputField(field) {
    return graphql_1.isInputType(field.type);
}
//# sourceMappingURL=transform-fields.js.map