gqtx/cjs/index.js

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

var graphql = require('graphql');

function builtInScalar(builtInType) {
    return {
        kind: 'Scalar',
        builtInType,
    };
}
function createTypesFactory() {
    return {
        String: builtInScalar(graphql.GraphQLString),
        Int: builtInScalar(graphql.GraphQLInt),
        Float: builtInScalar(graphql.GraphQLFloat),
        Boolean: builtInScalar(graphql.GraphQLBoolean),
        ID: builtInScalar(graphql.GraphQLID),
        scalarType({ name, description, serialize, parseValue, parseLiteral, }) {
            return {
                kind: 'Scalar',
                graphqlTypeConfig: {
                    name,
                    description,
                    serialize,
                    parseLiteral,
                    parseValue,
                },
            };
        },
        enumType({ name, description, values, }) {
            return {
                kind: 'Enum',
                name,
                description,
                values,
            };
        },
        arg(type, description) {
            return {
                kind: 'Argument',
                type,
                description,
            };
        },
        defaultArg(type, defaultArg, description) {
            return {
                kind: 'DefaultArgument',
                type: type,
                description,
                default: defaultArg,
            };
        },
        field(name, { type, args = {}, resolve, description, deprecationReason, extensions }) {
            return {
                kind: 'Field',
                name,
                type,
                description,
                deprecationReason,
                args,
                resolve,
                extensions
            };
        },
        defaultField(name, type, opts) {
            return {
                kind: 'Field',
                name: String(name),
                type,
                description: opts && opts.description,
                deprecationReason: opts && opts.deprecationReason,
                args: {},
                resolve: (src) => src[name],
            };
        },
        abstractField(name, type, opts) {
            return {
                kind: 'AbstractField',
                name,
                description: opts && opts.description,
                deprecationReason: opts && opts.deprecationReason,
                type,
            };
        },
        objectType({ name, description, interfaces = [], fields, isTypeOf, extensions, }) {
            const obj = {
                kind: 'ObjectType',
                name,
                description,
                interfaces,
                fieldsFn: undefined,
                isTypeOf,
                extensions,
            };
            obj.fieldsFn = () => fields(obj);
            return obj;
        },
        inputObjectType({ name, description, fields, }) {
            let inputObj = {
                kind: 'InputObject',
                name,
                description,
                fieldsFn: null,
            };
            inputObj.fieldsFn = () => fields(inputObj);
            return inputObj;
        },
        unionType({ name, types, resolveType, }) {
            return {
                kind: 'Union',
                name,
                types,
                resolveType,
            };
        },
        interfaceType({ name, description, interfaces = [], fields, }) {
            const obj = {
                kind: 'Interface',
                name,
                description,
                interfaces,
                fieldsFn: undefined,
            };
            obj.fieldsFn = () => fields(obj);
            return obj;
        },
        List(ofType) {
            return {
                kind: 'List',
                ofType: ofType,
            };
        },
        ListInput(ofType) {
            return {
                kind: 'ListInput',
                ofType: ofType,
            };
        },
        NonNull(ofType) {
            return {
                kind: 'NonNull',
                ofType: ofType,
            };
        },
        NonNullInput(ofType) {
            return {
                kind: 'NonNullInput',
                ofType: ofType,
            };
        },
        queryType({ name = 'Query', fields, }) {
            return {
                kind: 'ObjectType',
                name,
                interfaces: [],
                fieldsFn: () => fields,
            };
        },
        mutationType({ name = 'Mutation', fields, }) {
            return {
                kind: 'ObjectType',
                name,
                interfaces: [],
                fieldsFn: fields,
            };
        },
        subscriptionField(name, { type, args = {}, subscribe, resolve, description, deprecationReason, }) {
            return {
                kind: 'SubscriptionField',
                name,
                type,
                args,
                subscribe,
                resolve,
                description,
                deprecationReason,
            };
        },
        subscriptionType({ name = 'Subscription', fields, }) {
            return {
                kind: 'SubscriptionObject',
                name,
                fields,
            };
        },
    };
}

function buildGraphQLSchema(schema) {
    const typeMap = new Map();
    return new graphql.GraphQLSchema({
        query: toGraphQLOutputType(schema.query, typeMap),
        mutation: schema.mutation &&
            toGraphQLOutputType(schema.mutation, typeMap),
        subscription: schema.subscription && toGraphQLSubscriptionObject(schema.subscription, typeMap),
        types: schema.types && schema.types.map((type) => toGraphQLOutputType(type, typeMap)),
        directives: schema.directives
    });
}
function toGraphQLArgs(args, typeMap) {
    const graphqlArgs = {};
    Object.keys(args).forEach((k) => {
        const arg = args[k];
        graphqlArgs[k] = {
            type: toGraphQLInputType(arg.type, typeMap),
            description: arg.description,
            defaultValue: arg.kind === 'DefaultArgument' ? arg.default : undefined,
        };
    });
    return graphqlArgs;
}
function toGraphQLSubscriptionObject(subscriptionObj, typeMap) {
    return new graphql.GraphQLObjectType({
        name: subscriptionObj.name,
        fields: () => {
            const gqlFieldConfig = {};
            subscriptionObj.fields.forEach((field) => {
                gqlFieldConfig[field.name] = {
                    type: toGraphQLOutputType(field.type, typeMap),
                    description: field.description,
                    subscribe: field.subscribe,
                    resolve: field.resolve,
                    args: toGraphQLArgs(field.args, typeMap),
                    deprecationReason: field.deprecationReason,
                };
            });
            return gqlFieldConfig;
        },
    });
}
function toGraphQLInputType(t, typeMap) {
    const found = typeMap.get(t);
    if (found) {
        return typeMap.get(t);
    }
    switch (t.kind) {
        case 'Scalar':
        case 'Enum':
            return toGraphQLOutputType(t, typeMap);
        case 'NonNullInput':
            return new graphql.GraphQLNonNull(toGraphQLInputType(t.ofType, typeMap));
        case 'ListInput':
            return new graphql.GraphQLList(toGraphQLInputType(t.ofType, typeMap));
        case 'InputObject':
            const fields = t.fieldsFn();
            function graphqlFields() {
                const gqlFieldConfig = {};
                Object.keys(fields).forEach((k) => {
                    const field = fields[k];
                    gqlFieldConfig[k] = {
                        type: toGraphQLInputType(field.type, typeMap),
                        description: field.description,
                        deprecationReason: field.deprecationReason,
                    };
                });
                return gqlFieldConfig;
            }
            const obj = new graphql.GraphQLInputObjectType({
                name: t.name,
                fields: graphqlFields,
            });
            typeMap.set(t, obj);
            return obj;
    }
}
function toGraphQLOutputType(t, typeMap) {
    const found = typeMap.get(t);
    if (found) {
        return found;
    }
    switch (t.kind) {
        case 'Scalar':
            let scalar;
            if ('builtInType' in t) {
                scalar = t.builtInType;
            }
            else {
                scalar = new graphql.GraphQLScalarType({
                    ...t.graphqlTypeConfig,
                });
            }
            typeMap.set(t, scalar);
            return scalar;
        case 'Enum':
            const enumT = new graphql.GraphQLEnumType({
                name: t.name,
                description: t.description,
                values: t.values.reduce((acc, val) => {
                    acc[val.name] = {
                        value: val.value,
                        deprecationReason: val.deprecationReason,
                        description: val.description,
                    };
                    return acc;
                }, {}),
            });
            typeMap.set(t, enumT);
            return enumT;
        case 'NonNull':
            return new graphql.GraphQLNonNull(toGraphQLOutputType(t.ofType, typeMap));
        case 'List':
            return new graphql.GraphQLList(toGraphQLOutputType(t.ofType, typeMap));
        case 'ObjectType':
            const obj = new graphql.GraphQLObjectType({
                name: t.name,
                interfaces: t.interfaces.map((intf) => toGraphQLOutputType(intf, typeMap)),
                isTypeOf: t.isTypeOf,
                fields: () => {
                    const fields = t.fieldsFn();
                    const gqlFieldConfig = {};
                    fields.forEach((field) => {
                        gqlFieldConfig[field.name] = {
                            type: toGraphQLOutputType(field.type, typeMap),
                            description: field.description,
                            resolve: field.resolve,
                            args: toGraphQLArgs(field.args, typeMap),
                            deprecationReason: field.deprecationReason,
                            extensions: field.extensions
                        };
                    });
                    return gqlFieldConfig;
                },
                extensions: t.extensions,
            });
            typeMap.set(t, obj);
            return obj;
        case 'Union':
            const union = new graphql.GraphQLUnionType({
                name: t.name,
                types: t.types.map((t) => toGraphQLOutputType(t, typeMap)),
                resolveType: async (src, ctx, info) => {
                    const resolved = await t.resolveType(src, ctx, info);
                    if (typeof resolved === 'string' || resolved == null)
                        return resolved;
                    return typeMap.get(resolved);
                },
            });
            typeMap.set(t, union);
            return union;
        case 'Interface':
            const intf = new graphql.GraphQLInterfaceType({
                name: t.name,
                fields: () => {
                    const fields = t.fieldsFn();
                    const result = {};
                    fields.forEach((field) => {
                        result[field.name] = {
                            type: toGraphQLOutputType(field.type, typeMap),
                            description: field.description,
                            deprecationReason: field.deprecationReason,
                        };
                    });
                    return result;
                },
                interfaces: t.interfaces.map((intf) => toGraphQLOutputType(intf, typeMap)),
            });
            typeMap.set(t, intf);
            return intf;
    }
}

exports.buildGraphQLSchema = buildGraphQLSchema;
exports.createTypesFactory = createTypesFactory;
exports.toGraphQLInputType = toGraphQLInputType;
exports.toGraphQLOutputType = toGraphQLOutputType;