@blissfully/elm-graphql/lib/query-to-decoder.js

/**
 * Copyright (c) 2016, John Hewson
 * All rights reserved.
 */
"use strict";
var elm_ast_1 = require('./elm-ast');
var type_1 = require('graphql/type');
var utilities_1 = require('graphql/utilities');
var query_to_elm_1 = require('./query-to-elm');
function decoderForQuery(def, info, schema, fragmentDefinitionMap, seenFragments) {
    return decoderFor(def, info, schema, fragmentDefinitionMap, seenFragments);
}
exports.decoderForQuery = decoderForQuery;
function decoderForFragment(def, info, schema, fragmentDefinitionMap, seenFragments) {
    return decoderFor(def, info, schema, fragmentDefinitionMap, seenFragments);
}
exports.decoderForFragment = decoderForFragment;
function decoderFor(def, info, schema, fragmentDefinitionMap, seenFragments) {
    function walkDefinition(def, info) {
        if (def.kind == 'OperationDefinition') {
            return walkOperationDefinition(def, info);
        }
        else if (def.kind == 'FragmentDefinition') {
            return walkFragmentDefinition(def, info);
        }
    }
    function walkOperationDefinition(def, info) {
        info.enter(def);
        if (def.operation == 'query' || def.operation == 'mutation') {
            var decls = [];
            // Name
            var name_1;
            if (def.name) {
                name_1 = def.name.value;
            }
            else {
                name_1 = 'AnonymousQuery';
            }
            var resultType = name_1[0].toUpperCase() + name_1.substr(1);
            // todo: Directives
            // SelectionSet
            var expr = walkSelectionSet(def.selectionSet, info);
            // VariableDefinition
            var parameters = [];
            if (def.variableDefinitions) {
                for (var _i = 0, _a = def.variableDefinitions; _i < _a.length; _i++) {
                    var varDef = _a[_i];
                    var name_2 = varDef.variable.name.value;
                    var type = elm_ast_1.typeToString(query_to_elm_1.typeToElm(utilities_1.typeFromAST(schema, varDef.type)), 0);
                    // todo: default value
                    parameters.push({ name: name_2, type: type });
                }
            }
            info.leave(def);
            return { expr: 'map ' + resultType + ' ' + expr.expr };
        }
    }
    function walkFragmentDefinition(def, info) {
        info.enter(def);
        var name = def.name.value;
        var decls = [];
        var resultType = name[0].toUpperCase() + name.substr(1);
        // todo: Directives
        // SelectionSet
        var fields = walkSelectionSet(def.selectionSet, info);
        var fieldNames = getSelectionSetFields(def.selectionSet, info);
        var shape = "(\\" + fieldNames.join(' ') + " -> { " + fieldNames.map(function (f) { return f + ' = ' + f; }).join(', ') + " })";
        info.leave(def);
        return { expr: 'map ' + shape + ' ' + fields.expr };
    }
    function walkSelectionSet(selSet, info, seenFields) {
        if (seenFields === void 0) { seenFields = []; }
        info.enter(selSet);
        var fields = [];
        for (var _i = 0, _a = selSet.selections; _i < _a.length; _i++) {
            var sel = _a[_i];
            if (sel.kind == 'Field') {
                var field = sel;
                if (seenFields.indexOf(field.name.value) == -1) {
                    fields.push(walkField(field, info));
                    seenFields.push(field.name.value);
                }
            }
            else if (sel.kind == 'FragmentSpread') {
                // expand out all fragment spreads
                var spreadName = sel.name.value;
                var def_1 = fragmentDefinitionMap[spreadName];
                fields.push(walkSelectionSet(def_1.selectionSet, info, seenFields));
            }
            else if (sel.kind == 'InlineFragment') {
                throw new Error('Should not happen');
            }
        }
        info.leave(selSet);
        return { expr: fields.map(function (f) { return f.expr; }).filter(function (e) { return e.length > 0; }).join('\n        |: ') };
    }
    function getSelectionSetFields(selSet, info) {
        info.enter(selSet);
        var fields = [];
        for (var _i = 0, _a = selSet.selections; _i < _a.length; _i++) {
            var sel = _a[_i];
            if (sel.kind == 'Field') {
                var field = sel;
                var name_3 = query_to_elm_1.elmSafeName(field.name.value);
                if (field.alias) {
                    name_3 = query_to_elm_1.elmSafeName(field.alias.value);
                }
                if (fields.indexOf(name_3) == -1) {
                    fields.push(name_3);
                }
            }
            else if (sel.kind == 'FragmentSpread') {
                // expand out all fragment spreads
                var spreadName = sel.name.value;
                var def_2 = fragmentDefinitionMap[spreadName];
                for (var _b = 0, _c = getSelectionSetFields(def_2.selectionSet, info); _b < _c.length; _b++) {
                    var name_4 = _c[_b];
                    if (fields.indexOf(name_4) == -1) {
                        fields.push(name_4);
                    }
                }
            }
            else if (sel.kind == 'InlineFragment') {
                throw new Error('Should not happen');
            }
        }
        info.leave(selSet);
        return fields;
    }
    function walkField(field, info) {
        info.enter(field);
        // Name
        var name = query_to_elm_1.elmSafeName(field.name.value);
        var originalName = field.name.value;
        var info_type = info.getType();
        var isMaybe = false;
        if (info_type instanceof type_1.GraphQLNonNull) {
            info_type = info_type['ofType'];
        }
        else {
            isMaybe = true;
        }
        // Alias
        if (field.alias) {
            name = query_to_elm_1.elmSafeName(field.alias.value);
            originalName = field.alias.value;
        }
        // Arguments (opt)
        var args = field.arguments; // e.g. id: "1000"
        // todo: Directives
        if (query_to_elm_1.getRootType(info_type) instanceof type_1.GraphQLUnionType) {
            // Union
            return walkUnion(originalName, field, info);
        }
        else {
            // SelectionSet
            if (field.selectionSet) {
                var prefix = '';
                if (info_type instanceof type_1.GraphQLList) {
                    prefix = 'list ';
                }
                var fields = walkSelectionSet(field.selectionSet, info);
                info.leave(field);
                var fieldNames = getSelectionSetFields(field.selectionSet, info);
                var shape = "(\\" + fieldNames.join(' ') + " -> { " + fieldNames.map(function (f) { return f + ' = ' + f; }).join(', ') + " })";
                var left = '(field "' + originalName + '" ';
                var right = '(map ' + shape + ' ' + fields.expr + '))';
                var indent = '        ';
                if (prefix) {
                    right = '(' + prefix + right + ')';
                }
                if (isMaybe) {
                    right = '(' + 'maybe ' + right + ')';
                }
                return { expr: left + indent + right };
            }
            else {
                var decoder = leafTypeToDecoder(info_type);
                info.leave(field);
                var expr = { expr: '(field "' + originalName + '" (' + decoder + '))' };
                if (isMaybe) {
                    expr = { expr: '(maybe ' + expr.expr + ')' };
                }
                return expr;
            }
        }
    }
    function walkUnion(originalName, field, info) {
        var decoder = '\n        (\\typename -> case typename of';
        var indent = '            ';
        var info_type = info.getType();
        var isMaybe = false;
        if (info_type instanceof type_1.GraphQLNonNull) {
            info_type = info_type['ofType'];
        }
        else {
            isMaybe = true;
        }
        var prefix = '';
        var isList = false;
        if (info_type instanceof type_1.GraphQLList) {
            prefix = 'list ';
            isList = true;
        }
        for (var _i = 0, _a = field.selectionSet.selections; _i < _a.length; _i++) {
            var sel = _a[_i];
            if (sel.kind == 'InlineFragment') {
                var inlineFragment = sel;
                decoder += "\n" + indent + "\"" + inlineFragment.typeCondition.name.value + "\" -> ";
                info.enter(inlineFragment);
                var fields = walkSelectionSet(inlineFragment.selectionSet, info);
                info.leave(inlineFragment);
                var fieldNames = getSelectionSetFields(inlineFragment.selectionSet, info);
                var ctor = query_to_elm_1.elmSafeName(inlineFragment.typeCondition.name.value);
                var shape = "(\\" + fieldNames.join(' ') + " -> " + ctor + " { " + fieldNames.map(function (f) { return f + ' = ' + f; }).join(', ') + " })";
                var right = '(map ' + shape + ' ' + fields.expr + ')';
                decoder += right;
            }
            else if (sel.kind == 'Field') {
                var field_1 = sel;
                if (field_1.name.value != '__typename') {
                    throw new Error('Unexpected field: ' + field_1.name.value);
                }
            }
            else {
                throw new Error('Unexpected: ' + sel.kind);
            }
        }
        decoder += "\n" + indent + "_ -> fail \"Unexpected union type\")";
        decoder = '((field "__typename" string) |> andThen ' + decoder + ')';
        if (prefix) {
            decoder = '(' + prefix + decoder + ')';
        }
        if (isMaybe) {
            decoder = '(' + 'maybe ' + decoder + ')';
        }
        return { expr: '(field "' + originalName + '" ' + decoder + ')' };
    }
    function leafTypeToDecoder(type) {
        var prefix = '';
        if (type instanceof type_1.GraphQLList) {
            prefix = 'list ';
            type = type['ofType'];
        }
        // leaf types only
        if (type instanceof type_1.GraphQLScalarType) {
            switch (type.name) {
                case 'Int': return prefix + 'int';
                case 'Float': return prefix + 'float';
                case 'Boolean': return prefix + 'bool';
                case 'ID':
                case 'String': return prefix + 'string';
            }
        }
        else if (type instanceof type_1.GraphQLEnumType) {
            return prefix + type.name.toLowerCase() + 'Decoder';
        }
        else {
            throw new Error('not a leaf type: ' + type.name);
        }
    }
    return walkDefinition(def, info);
}
exports.decoderFor = decoderFor;
//# sourceMappingURL=query-to-decoder.js.map