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

/**
 * Copyright (c) 2016, John Hewson
 * All rights reserved.
 */
"use strict";
/// <reference path="../typings/node.d.ts" />
/// <reference path="../typings/es6-function.d.ts" />
/// <reference path="../typings/graphql-types.d.ts" />
/// <reference path="../typings/graphql-language.d.ts" />
/// <reference path="../typings/graphql-utilities.d.ts" />
var language_1 = require("graphql/language");
var elm_ast_1 = require('./elm-ast');
var type_1 = require('graphql/type');
var utilities_1 = require('graphql/utilities');
var query_to_decoder_1 = require('./query-to-decoder');
var alphabet = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p',
    'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'];
function queryToElm(graphql, moduleName, liveUrl, verb, schema) {
    var queryDocument = language_1.parse(graphql);
    var _a = translateQuery(liveUrl, queryDocument, schema, verb), decls = _a[0], expose = _a[1];
    return elm_ast_1.moduleToString(moduleName, expose, [
        'Task exposing (Task)',
        'Json.Decode.Extra exposing ((|:))',
        'Json.Decode exposing (..)',
        'Json.Encode exposing (encode)',
        'Http',
        'GraphQL.Client as GraphQL exposing (Context, apply, maybeEncode, GQLError, HttpMapper)'
    ], decls);
}
exports.queryToElm = queryToElm;
function translateQuery(uri, doc, schema, verb) {
    var expose = [];
    var fragmentDefinitionMap = {};
    function walkQueryDocument(doc, info) {
        var decls = [];
        // decls.push(new ElmFunctionDecl('endpointUrl', [], new ElmTypeName('String'), { expr: `"${uri}"` }));
        buildFragmentDefinitionMap(doc);
        var seenFragments = {};
        var seenEnums = {};
        var seenUnions = {};
        for (var _i = 0, _a = doc.definitions; _i < _a.length; _i++) {
            var def = _a[_i];
            if (def.kind == 'OperationDefinition') {
                decls.push.apply(decls, walkOperationDefinition(def, info));
            }
            else if (def.kind == 'FragmentDefinition') {
                decls.push.apply(decls, walkFragmentDefinition(def, info));
            }
            collectFragments(def, seenFragments);
            collectEnums(def, seenEnums);
            collectUnions(def, seenUnions);
        }
        for (var fragName in seenFragments) {
            var frag = seenFragments[fragName];
            var decodeFragFuncName = fragName[0].toLowerCase() + fragName.substr(1) + 'Decoder';
            var fragTypeName = fragName[0].toUpperCase() + fragName.substr(1);
            decls.push(new elm_ast_1.ElmFunctionDecl(decodeFragFuncName, [], new elm_ast_1.ElmTypeName('Decoder ' + fragTypeName), query_to_decoder_1.decoderForFragment(frag, info, schema, fragmentDefinitionMap, seenFragments)));
            expose.push(decodeFragFuncName);
            expose.push(fragTypeName);
        }
        for (var name_1 in seenEnums) {
            var seenEnum = seenEnums[name_1];
            decls.unshift(walkEnum(seenEnum));
            decls.push(decoderForEnum(seenEnum));
            expose.push(seenEnum.name + "(..)");
        }
        for (var name_2 in seenUnions) {
            var union = seenUnions[name_2];
            decls.unshift(walkUnion(union));
            expose.push((getRootType(union)['name'] + "(..)"));
        }
        return [decls, expose];
    }
    function buildFragmentDefinitionMap(doc) {
        language_1.visit(doc, {
            enter: function (node) {
                if (node.kind == 'FragmentDefinition') {
                    var def = node;
                    var name_3 = def.name.value;
                    fragmentDefinitionMap[name_3] = def;
                }
            },
            leave: function (node) { }
        });
    }
    function collectFragments(def, fragments) {
        if (fragments === void 0) { fragments = {}; }
        language_1.visit(doc, {
            enter: function (node) {
                if (node.kind == 'FragmentSpread') {
                    var spread = node;
                    var name_4 = spread.name.value;
                    fragments[name_4] = fragmentDefinitionMap[name_4];
                }
            },
            leave: function (node) { }
        });
        return fragments;
    }
    // Retrieve fragments used in the specified query definition selection set
    function queryFragments(selectionSet, fragments) {
        if (fragments === void 0) { fragments = {}; }
        if (selectionSet) {
            language_1.visit(selectionSet, {
                enter: function (node) {
                    if (node.kind == 'FragmentSpread') {
                        var spread = node;
                        var name_5 = spread.name.value;
                        var frag = fragments[name_5] = fragmentDefinitionMap[name_5];
                        fragments = queryFragments(frag.selectionSet, fragments);
                    }
                },
                leave: function (node) {
                }
            });
        }
        return fragments;
    }
    function collectUnions(def, unions) {
        if (unions === void 0) { unions = {}; }
        var info = new utilities_1.TypeInfo(schema);
        language_1.visit(doc, {
            enter: function (node, key, parent) {
                if (node.kind == 'InlineFragment') {
                    var parentType = info.getType();
                    unions[parentType.name] = parentType;
                }
                info.enter(node);
            },
            leave: function (node) {
                info.leave(node);
            }
        });
        return unions;
    }
    function collectEnums(def, enums) {
        if (enums === void 0) { enums = {}; }
        var info = new utilities_1.TypeInfo(schema);
        language_1.visit(doc, {
            enter: function (node, key, parent) {
                info.enter(node);
                if (node.kind == 'Field') {
                    var field = node;
                    var name_6 = field.name.value;
                    var type = info.getType();
                    collectEnumsForType(type, enums);
                }
                // todo: do we need to walk into fragment spreads?
            },
            leave: function (node, key, parent) {
                info.leave(node);
            }
        });
        return enums;
    }
    function collectEnumsForType(type, seen, seenTypes) {
        if (seen === void 0) { seen = {}; }
        if (seenTypes === void 0) { seenTypes = {}; }
        if (type instanceof type_1.GraphQLEnumType) {
            seen[type.name] = type;
        }
        else if (type instanceof type_1.GraphQLList) {
            collectEnumsForType(type.ofType, seen, seenTypes);
        }
        else if (type instanceof type_1.GraphQLObjectType ||
            type instanceof type_1.GraphQLInterfaceType ||
            type instanceof type_1.GraphQLInputObjectType) {
            if (seenTypes[type.name]) {
                return;
            }
            else {
                seenTypes[type.name] = type;
            }
            var fieldMap = type.getFields();
            for (var fieldName in fieldMap) {
                var field = fieldMap[fieldName];
                collectEnumsForType(field.type, seen, seenTypes);
            }
        }
        else if (type instanceof type_1.GraphQLNonNull) {
            collectEnumsForType(type.ofType, seen, seenTypes);
        }
    }
    function walkEnum(enumType) {
        console.log(enumType.getValues());
        return new elm_ast_1.ElmTypeDecl(enumType.name, enumType.getValues().map(function (v) { return v.name[0].toUpperCase() + v.name.substr(1); }));
    }
    function decoderForEnum(enumType) {
        // might need to be Maybe Episode, with None -> fail in the Decoder
        var decoderTypeName = enumType.name[0].toUpperCase() + enumType.name.substr(1);
        return new elm_ast_1.ElmFunctionDecl(enumType.name.toLowerCase() + 'Decoder', [], new elm_ast_1.ElmTypeName('Decoder ' + decoderTypeName), { expr: 'string |> andThen (\\s ->\n' +
                '        case s of\n' + enumType.getValues().map(function (v) {
                return '            "' + v.name + '" -> succeed ' + v.name[0].toUpperCase() + v.name.substr(1);
            }).join('\n') + '\n' +
                '            _ -> fail "Unknown ' + enumType.name + '")'
        });
    }
    function walkUnion(union) {
        union = getRootType(union);
        var types = union.getTypes();
        var params = types.map(function (t, i) { return alphabet[i]; }).join(' ');
        return new elm_ast_1.ElmTypeDecl(getRootType(union)['name'] + ' ' + params, types.map(function (t, i) { return elmSafeName(t.name) + ' ' + alphabet[i]; }));
    }
    function walkOperationDefinition(def, info) {
        info.enter(def);
        if (!info.getType()) {
            throw new Error("GraphQL schema does not define " + def.operation + " '" + def.name.value + "'");
        }
        if (def.operation == 'query' || def.operation == 'mutation') {
            var decls = [];
            // Name
            var name_7;
            if (def.name) {
                name_7 = def.name.value;
            }
            else {
                name_7 = 'AnonymousQuery';
            }
            var resultType = name_7[0].toUpperCase() + name_7.substr(1);
            // todo: Directives
            // SelectionSet
            var _a = walkSelectionSet(def.selectionSet, info), fields = _a[0], spreads = _a[1];
            // todo: use spreads...
            decls.push(new elm_ast_1.ElmTypeAliasDecl(resultType, new elm_ast_1.ElmTypeRecord(fields)));
            // VariableDefinition
            var parameters = [];
            if (def.variableDefinitions) {
                for (var _i = 0, _b = def.variableDefinitions; _i < _b.length; _i++) {
                    var varDef = _b[_i];
                    var name_8 = varDef.variable.name.value;
                    var schemaType = utilities_1.typeFromAST(schema, varDef.type);
                    var type = typeToElm(schemaType);
                    parameters.push({ name: name_8, type: type, schemaType: schemaType, hasDefault: varDef.defaultValue != null });
                }
            }
            var funcName = name_7[0].toLowerCase() + name_7.substr(1);
            // grabs all fragments
            var seenFragments = collectFragments(def);
            // grabs all fragment dependencies in the query
            var qFragments = queryFragments(def.selectionSet);
            var query = '';
            for (var name_9 in qFragments) {
                query += language_1.print(qFragments[name_9]) + ' ';
            }
            query += language_1.print(def);
            var decodeFuncName = resultType[0].toLowerCase() + resultType.substr(1) + 'Decoder';
            expose.push(funcName);
            expose.push(resultType);
            var resultTypeName = resultType[0].toUpperCase() + resultType.substr(1);
            var elmContextType = new elm_ast_1.ElmTypeName("Context");
            var elmMapperType = new elm_ast_1.ElmTypeName("HttpMapper success result");
            var elmToMsgType = new elm_ast_1.ElmTypeName("(result -> msg)");
            var elmToResultMapType = new elm_ast_1.ElmTypeName("(" + resultTypeName + " -> success)");
            var elmParamsType = new elm_ast_1.ElmTypeRecord(parameters.map(function (p) { return new elm_ast_1.ElmFieldDecl(p.name, p.type); }));
            var elmContext = new elm_ast_1.ElmParameterDecl('context', elmContextType);
            var elmMapper = new elm_ast_1.ElmParameterDecl('mapper', elmMapperType);
            var elmToMsg = new elm_ast_1.ElmParameterDecl('toMsg', elmToMsgType);
            var elmToResultMap = new elm_ast_1.ElmParameterDecl('mapDecoder', elmToResultMapType);
            var elmParams = new elm_ast_1.ElmParameterDecl('params', elmParamsType);
            var elmParamsDecl = elmParamsType.fields.length > 0 ? [elmContext, elmParams, elmToResultMap, elmMapper, elmToMsg] : [elmContext, elmToResultMap, elmMapper, elmToMsg];
            var methodParam = def.operation == 'query' ? "\"" + verb + "\" " : '';
            decls.push(new elm_ast_1.ElmFunctionDecl(funcName, elmParamsDecl, new elm_ast_1.ElmTypeName("Cmd msg"), {
                // we use awkward variable names to avoid naming collisions with query parameters
                expr: ("let graphQLQuery = \"\"\"" + query.replace(/\s+/g, ' ') + "\"\"\" in\n") +
                    "    let graphQLParams =\n" +
                    "            Json.Encode.object\n" +
                    "                [ " +
                    parameters.map(function (p) {
                        var encoder;
                        if (p.hasDefault) {
                            encoder = ("case params." + p.name + " of") +
                                ("\n                            Just val -> " + encoderForInputType(p.schemaType, true) + " val") +
                                "\n                            Nothing -> Json.Encode.null";
                        }
                        else {
                            encoder = encoderForInputType(p.schemaType, true, 'params.' + p.name);
                        }
                        return "(\"" + p.name + "\", " + encoder + ")";
                    })
                        .join("\n                , ") + '\n' +
                    "                ]\n" +
                    "    in\n" +
                    ("    GraphQL." + def.operation + " context " + methodParam + "graphQLQuery \"" + name_7 + "\" graphQLParams (Json.Decode.map mapDecoder " + decodeFuncName + ") mapper toMsg")
            }));
            decls.push(new elm_ast_1.ElmFunctionDecl(decodeFuncName, [], new elm_ast_1.ElmTypeName('Decoder ' + resultTypeName), query_to_decoder_1.decoderForQuery(def, info, schema, fragmentDefinitionMap, seenFragments)));
            info.leave(def);
            return decls;
        }
    }
    function encoderForInputType(type, isNonNull, value) {
        var encoder;
        var isMaybe = false;
        if (type instanceof type_1.GraphQLNonNull) {
            type = type['ofType'];
        }
        else {
            isMaybe = true;
        }
        if (type instanceof type_1.GraphQLInputObjectType) {
            var fieldEncoders = [];
            var fields = type.getFields();
            for (var name_10 in fields) {
                var field = fields[name_10];
                var valuePath = value + '.' + field.name;
                fieldEncoders.push("(\"" + field.name + "\", " + encoderForInputType(field.type, false, valuePath) + ")");
            }
            encoder = '(Json.Encode.object [' + fieldEncoders.join(", ") + '])';
        }
        else if (type instanceof type_1.GraphQLList) {
            encoder = '(Json.Encode.list (List.map (\\x -> ' + encoderForInputType(type.ofType, true, 'x') + ') ' + value + '))';
        }
        else if (type instanceof type_1.GraphQLScalarType) {
            switch (type.name) {
                case 'Int':
                    encoder = 'Json.Encode.int ' + value;
                    break;
                case 'Float':
                    encoder = 'Json.Encode.float ' + value;
                    break;
                case 'Boolean':
                    encoder = 'Json.Encode.bool ' + value;
                    break;
                case 'ID':
                case 'String':
                    encoder = 'Json.Encode.string ' + value;
                    break;
            }
        }
        else {
            throw new Error('not implemented: ' + type.constructor.name);
        }
        if (isMaybe) {
            encoder = '(maybeEncode ' + encoder + ')';
        }
        return encoder;
    }
    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 _a = walkSelectionSet(def.selectionSet, info), fields = _a[0], spreads = _a[1];
        var type = new elm_ast_1.ElmTypeRecord(fields, 'a');
        for (var _i = 0, spreads_1 = spreads; _i < spreads_1.length; _i++) {
            var spreadName = spreads_1[_i];
            var typeName = spreadName[0].toUpperCase() + spreadName.substr(1) + '_';
            type = new elm_ast_1.ElmTypeApp(typeName, [type]);
        }
        decls.push(new elm_ast_1.ElmTypeAliasDecl(resultType + '_', type, ['a']));
        decls.push(new elm_ast_1.ElmTypeAliasDecl(resultType, new elm_ast_1.ElmTypeApp(resultType + '_', [new elm_ast_1.ElmTypeRecord([])])));
        info.leave(def);
        return decls;
    }
    function walkSelectionSet(selSet, info) {
        info.enter(selSet);
        var fields = [];
        var spreads = [];
        if (getRootType(info.getType()) instanceof type_1.GraphQLUnionType) {
            var type = walkUnionSelectionSet(selSet, info);
            return [[], [], type];
        }
        else {
            for (var _i = 0, _a = selSet.selections; _i < _a.length; _i++) {
                var sel = _a[_i];
                if (sel.kind == 'Field') {
                    var field = sel;
                    fields.push(walkField(field, info));
                }
                else if (sel.kind == 'FragmentSpread') {
                    spreads.push(sel.name.value);
                }
                else if (sel.kind == 'InlineFragment') {
                    var frag = sel;
                    // todo: InlineFragment
                    throw new Error('not implemented: InlineFragment on ' + frag.typeCondition.name.value);
                }
            }
            info.leave(selSet);
            return [fields, spreads, null];
        }
    }
    function walkUnionSelectionSet(selSet, info) {
        var union = getRootType(info.getType());
        var typeMap = {};
        for (var _i = 0, _a = union.getTypes(); _i < _a.length; _i++) {
            var type = _a[_i];
            typeMap[type.name] = new elm_ast_1.ElmTypeRecord([]);
        }
        for (var _b = 0, _c = selSet.selections; _b < _c.length; _b++) {
            var sel = _c[_b];
            if (sel.kind == 'InlineFragment') {
                var inline = sel;
                info.enter(inline);
                var _d = walkSelectionSet(inline.selectionSet, info), fields = _d[0], spreads = _d[1];
                info.leave(inline);
                // record
                var type = new elm_ast_1.ElmTypeRecord(fields);
                // spreads
                for (var _e = 0, spreads_2 = spreads; _e < spreads_2.length; _e++) {
                    var spreadName = spreads_2[_e];
                    var typeName = spreadName[0].toUpperCase() + spreadName.substr(1) + '_';
                    type = new elm_ast_1.ElmTypeApp(typeName, [type]);
                }
                typeMap[inline.typeCondition.name.value] = type;
            }
        }
        var args = [];
        for (var name_11 in typeMap) {
            args.push(typeMap[name_11]);
        }
        return new elm_ast_1.ElmTypeApp(getRootType(union)['name'], args);
    }
    function walkField(field, info) {
        info.enter(field);
        var info_type = info.getType();
        // Name
        var name = elmSafeName(field.name.value);
        // Alias
        if (field.alias) {
            name = elmSafeName(field.alias.value);
        }
        // todo: Arguments, such as `id: $someId`, where $someId is a variable
        var args = field.arguments; // e.g. id: "1000"
        // todo: Directives
        // SelectionSet
        if (field.selectionSet) {
            var isMaybe = false;
            if (info_type instanceof type_1.GraphQLNonNull) {
                info_type = info_type['ofType'];
            }
            else {
                isMaybe = true;
            }
            var isList = info_type instanceof type_1.GraphQLList;
            var _a = walkSelectionSet(field.selectionSet, info), fields = _a[0], spreads = _a[1], union = _a[2];
            var type = union ? union : new elm_ast_1.ElmTypeRecord(fields);
            for (var _i = 0, spreads_3 = spreads; _i < spreads_3.length; _i++) {
                var spreadName = spreads_3[_i];
                var typeName = spreadName[0].toUpperCase() + spreadName.substr(1) + '_';
                type = new elm_ast_1.ElmTypeApp(typeName, [type]);
            }
            if (isList) {
                type = new elm_ast_1.ElmTypeApp('List', [type]);
            }
            if (isMaybe) {
                type = new elm_ast_1.ElmTypeApp('Maybe', [type]);
            }
            info.leave(field);
            return new elm_ast_1.ElmFieldDecl(name, type);
        }
        else {
            if (!info.getType()) {
                var errorMessage = "Unknown GraphQL field: ' " + field.name.value + "\n" + JSON.stringify(info) + "\n";
                throw new Error('Unknown GraphQL field: ' + field.name.value);
            }
            var type = typeToElm(info.getType());
            info.leave(field);
            return new elm_ast_1.ElmFieldDecl(name, type);
        }
    }
    return walkQueryDocument(doc, new utilities_1.TypeInfo(schema));
}
function getRootType(type) {
    if (type instanceof type_1.GraphQLList) {
        return getRootType(type['ofType']);
    }
    else if (type instanceof type_1.GraphQLNonNull) {
        return getRootType(type['ofType']);
    }
    else {
        return type;
    }
}
exports.getRootType = getRootType;
function typeToElm(type, isNonNull) {
    if (isNonNull === void 0) { isNonNull = false; }
    var elmType;
    if (type instanceof type_1.GraphQLNonNull) {
        elmType = typeToElm(type.ofType, true);
    }
    else if (type instanceof type_1.GraphQLScalarType) {
        switch (type.name) {
            case 'Int':
                elmType = new elm_ast_1.ElmTypeName('Int');
                break;
            case 'Float':
                elmType = new elm_ast_1.ElmTypeName('Float');
                break;
            case 'Boolean':
                elmType = new elm_ast_1.ElmTypeName('Bool');
                break;
            case 'ID':
            case 'String':
                elmType = new elm_ast_1.ElmTypeName('String');
                break;
        }
    }
    else if (type instanceof type_1.GraphQLEnumType) {
        elmType = new elm_ast_1.ElmTypeName(type.name[0].toUpperCase() + type.name.substr(1));
    }
    else if (type instanceof type_1.GraphQLList) {
        elmType = new elm_ast_1.ElmTypeApp('List', [typeToElm(type.ofType, true)]);
    }
    else if (type instanceof type_1.GraphQLObjectType ||
        type instanceof type_1.GraphQLInterfaceType ||
        type instanceof type_1.GraphQLInputObjectType) {
        var fields = [];
        var fieldMap = type.getFields();
        for (var fieldName in fieldMap) {
            var field = fieldMap[fieldName];
            fields.push(new elm_ast_1.ElmFieldDecl(elmSafeName(fieldName), typeToElm(field.type)));
        }
        elmType = new elm_ast_1.ElmTypeRecord(fields);
    }
    else if (type instanceof type_1.GraphQLNonNull) {
        elmType = typeToElm(type.ofType, true);
    }
    else {
        throw new Error('Unexpected: ' + type.constructor.name);
    }
    if (!isNonNull && !(type instanceof type_1.GraphQLList) && !(type instanceof type_1.GraphQLNonNull)) {
        elmType = new elm_ast_1.ElmTypeApp('Maybe', [elmType]);
    }
    return elmType;
}
exports.typeToElm = typeToElm;
function elmSafeName(graphQlName) {
    switch (graphQlName) {
        case 'type': return "type_";
        case 'Task': return "Task_";
        case 'List': return "List_";
        case 'Http': return "Http_";
        case 'GraphQL': return "GraphQL_";
        // todo: more...
        default: return graphQlName;
    }
}
exports.elmSafeName = elmSafeName;
//# sourceMappingURL=query-to-elm.js.map