sofa-api 0.5.0 → 0.7.0

package/index.esm.js

@@ -0,0 +1,1050 @@
+import { __awaiter } from 'tslib';
+import { Router } from 'express';
+import { Kind, isListType, isNonNullType, getNamedType, isScalarType, isUnionType, isInterfaceType, isObjectType, getOperationAST, graphql, isEqualType, GraphQLBoolean, isInputObjectType, subscribe, print, parse, printType, isIntrospectionType } from 'graphql';
+import { camelCase, paramCase } from 'change-case';
+import { createLogger, transports, format } from 'winston';
+import { v4 } from 'uuid';
+import axios from 'axios';
+import { isAsyncIterable, forAwaitEach } from 'iterall';
+import { stringify } from 'yamljs';
+import { writeFileSync } from 'fs';
+import { titleCase } from 'title-case';
+
+const logger = createLogger({
+    transports: [new transports.Console()],
+    format: format.combine(format.colorize(), format.simple()),
+});
+
+let operationVariables = [];
+function addOperationVariable(variable) {
+    operationVariables.push(variable);
+}
+function resetOperationVariables() {
+    operationVariables = [];
+}
+function buildOperationName(name) {
+    return camelCase(name);
+}
+function buildOperation({ schema, kind, field, models, ignore, depthLimit, }) {
+    resetOperationVariables();
+    logger.debug(`[Sofa] Building ${field} ${kind}`);
+    const document = buildDocumentNode({
+        schema,
+        fieldName: field,
+        kind,
+        models,
+        ignore,
+        depthLimit: depthLimit || 1,
+    });
+    // attach variables
+    document.definitions[0].variableDefinitions = [
+        ...operationVariables,
+    ];
+    resetOperationVariables();
+    return document;
+}
+function buildDocumentNode({ schema, fieldName, kind, models, ignore, depthLimit, }) {
+    const typeMap = {
+        query: schema.getQueryType(),
+        mutation: schema.getMutationType(),
+        subscription: schema.getSubscriptionType(),
+    };
+    const type = typeMap[kind];
+    const field = type.getFields()[fieldName];
+    const operationName = buildOperationName(`${fieldName}_${kind}`);
+    if (field.args) {
+        field.args.forEach(arg => {
+            addOperationVariable(resolveVariable(arg));
+        });
+    }
+    const operationNode = {
+        kind: Kind.OPERATION_DEFINITION,
+        operation: kind,
+        name: {
+            kind: 'Name',
+            value: operationName,
+        },
+        variableDefinitions: [],
+        selectionSet: {
+            kind: Kind.SELECTION_SET,
+            selections: [
+                resolveField({
+                    type,
+                    field,
+                    models,
+                    firstCall: true,
+                    path: [],
+                    ancestors: [],
+                    ignore,
+                    depthLimit,
+                    schema,
+                }),
+            ],
+        },
+    };
+    const document = {
+        kind: Kind.DOCUMENT,
+        definitions: [operationNode],
+    };
+    return document;
+}
+function resolveSelectionSet({ parent, type, models, firstCall, path, ancestors, ignore, depthLimit, schema, }) {
+    if (isUnionType(type)) {
+        const types = type.getTypes();
+        return {
+            kind: Kind.SELECTION_SET,
+            selections: types
+                .filter(t => !hasCircularRef([...ancestors, t], {
+                depth: depthLimit,
+            }))
+                .map(t => {
+                return {
+                    kind: Kind.INLINE_FRAGMENT,
+                    typeCondition: {
+                        kind: Kind.NAMED_TYPE,
+                        name: {
+                            kind: Kind.NAME,
+                            value: t.name,
+                        },
+                    },
+                    selectionSet: resolveSelectionSet({
+                        parent: type,
+                        type: t,
+                        models,
+                        path,
+                        ancestors,
+                        ignore,
+                        depthLimit,
+                        schema,
+                    }),
+                };
+            }),
+        };
+    }
+    if (isInterfaceType(type)) {
+        const types = Object.values(schema.getTypeMap()).filter(t => isObjectType(t) && t.getInterfaces().includes(type));
+        return {
+            kind: Kind.SELECTION_SET,
+            selections: types
+                .filter(t => !hasCircularRef([...ancestors, t], {
+                depth: depthLimit,
+            }))
+                .map(t => {
+                return {
+                    kind: Kind.INLINE_FRAGMENT,
+                    typeCondition: {
+                        kind: Kind.NAMED_TYPE,
+                        name: {
+                            kind: Kind.NAME,
+                            value: t.name,
+                        },
+                    },
+                    selectionSet: resolveSelectionSet({
+                        parent: type,
+                        type: t,
+                        models,
+                        path,
+                        ancestors,
+                        ignore,
+                        depthLimit,
+                        schema,
+                    }),
+                };
+            }),
+        };
+    }
+    if (isObjectType(type)) {
+        const isIgnored = ignore.includes(type.name) ||
+            ignore.includes(`${parent.name}.${path[path.length - 1]}`);
+        const isModel = models.includes(type.name);
+        if (!firstCall && isModel && !isIgnored) {
+            return {
+                kind: Kind.SELECTION_SET,
+                selections: [
+                    {
+                        kind: Kind.FIELD,
+                        name: {
+                            kind: Kind.NAME,
+                            value: 'id',
+                        },
+                    },
+                ],
+            };
+        }
+        const fields = type.getFields();
+        return {
+            kind: Kind.SELECTION_SET,
+            selections: Object.keys(fields)
+                .filter(fieldName => {
+                return !hasCircularRef([...ancestors, getNamedType(fields[fieldName].type)], {
+                    depth: depthLimit,
+                });
+            })
+                .map(fieldName => {
+                return resolveField({
+                    type: type,
+                    field: fields[fieldName],
+                    models,
+                    path: [...path, fieldName],
+                    ancestors,
+                    ignore,
+                    depthLimit,
+                    schema,
+                });
+            }),
+        };
+    }
+}
+function resolveVariable(arg, name) {
+    function resolveVariableType(type) {
+        if (isListType(type)) {
+            return {
+                kind: Kind.LIST_TYPE,
+                type: resolveVariableType(type.ofType),
+            };
+        }
+        if (isNonNullType(type)) {
+            return {
+                kind: Kind.NON_NULL_TYPE,
+                type: resolveVariableType(type.ofType),
+            };
+        }
+        return {
+            kind: Kind.NAMED_TYPE,
+            name: {
+                kind: Kind.NAME,
+                value: type.name,
+            },
+        };
+    }
+    return {
+        kind: Kind.VARIABLE_DEFINITION,
+        variable: {
+            kind: Kind.VARIABLE,
+            name: {
+                kind: Kind.NAME,
+                value: name || arg.name,
+            },
+        },
+        type: resolveVariableType(arg.type),
+    };
+}
+function getArgumentName(name, path) {
+    return camelCase([...path, name].join('_'));
+}
+function resolveField({ type, field, models, firstCall, path, ancestors, ignore, depthLimit, schema, }) {
+    const namedType = getNamedType(field.type);
+    let args = [];
+    if (field.args && field.args.length) {
+        args = field.args.map(arg => {
+            if (!firstCall) {
+                addOperationVariable(resolveVariable(arg, getArgumentName(arg.name, path)));
+            }
+            return {
+                kind: Kind.ARGUMENT,
+                name: {
+                    kind: Kind.NAME,
+                    value: arg.name,
+                },
+                value: {
+                    kind: Kind.VARIABLE,
+                    name: {
+                        kind: Kind.NAME,
+                        value: getArgumentName(arg.name, path),
+                    },
+                },
+            };
+        });
+    }
+    if (!isScalarType(namedType)) {
+        return {
+            kind: Kind.FIELD,
+            name: {
+                kind: Kind.NAME,
+                value: field.name,
+            },
+            selectionSet: resolveSelectionSet({
+                parent: type,
+                type: namedType,
+                models,
+                firstCall,
+                path: [...path, field.name],
+                ancestors: [...ancestors, type],
+                ignore,
+                depthLimit,
+                schema,
+            }),
+            arguments: args,
+        };
+    }
+    return {
+        kind: Kind.FIELD,
+        name: {
+            kind: Kind.NAME,
+            value: field.name,
+        },
+        arguments: args,
+    };
+}
+function hasCircularRef(types, config = {
+    depth: 1,
+}) {
+    const type = types[types.length - 1];
+    if (isScalarType(type)) {
+        return false;
+    }
+    const size = types.filter(t => t.name === type.name).length;
+    return size > config.depth;
+}
+
+function getOperationInfo(doc) {
+    const op = getOperationAST(doc, null);
+    if (!op) {
+        return;
+    }
+    return {
+        operation: op,
+        name: op.name.value,
+        variables: op.variableDefinitions || [],
+    };
+}
+
+function convertName(name) {
+    return paramCase(name);
+}
+function isNil(val) {
+    return val == null;
+}
+
+function createSofa(config) {
+    logger.debug('[Sofa] Created');
+    const models = extractsModels(config.schema);
+    const ignore = config.ignore || [];
+    logger.debug(`[Sofa] models: ${models.join(', ')}`);
+    logger.debug(`[Sofa] ignore: ${ignore.join(', ')}`);
+    return Object.assign({ context({ req }) {
+            return { req };
+        }, execute: graphql, models,
+        ignore }, config);
+}
+// Objects and Unions are the only things that are used to define return types
+// and both might contain an ID
+// We don't treat Unions as models because
+// they might represent an Object that is not a model
+// We check it later, when an operation is being built
+function extractsModels(schema) {
+    const modelMap = {};
+    const query = schema.getQueryType();
+    const fields = query.getFields();
+    // if Query[type] (no args) and Query[type](just id as an argument)
+    // loop through every field
+    for (const fieldName in fields) {
+        const field = fields[fieldName];
+        const namedType = getNamedType(field.type);
+        if (hasID(namedType)) {
+            if (!modelMap[namedType.name]) {
+                modelMap[namedType.name] = {};
+            }
+            if (isArrayOf(field.type, namedType)) {
+                // check if type is a list
+                // check if name of a field matches a name of a named type (in plural)
+                // check if has no non-optional arguments
+                // add to registry with `list: true`
+                const sameName = isNameEqual(field.name, namedType.name + 's');
+                const allOptionalArguments = !field.args.some(arg => isNonNullType(arg.type));
+                modelMap[namedType.name].list = sameName && allOptionalArguments;
+            }
+            else if (isObjectType(field.type) ||
+                (isNonNullType(field.type) && isObjectType(field.type.ofType))) {
+                // check if type is a graphql object type
+                // check if name of a field matches with name of an object type
+                // check if has only one argument named `id`
+                // add to registry with `single: true`
+                const sameName = isNameEqual(field.name, namedType.name);
+                const hasIdArgument = field.args.length === 1 && field.args[0].name === 'id';
+                modelMap[namedType.name].single = sameName && hasIdArgument;
+            }
+        }
+    }
+    return Object.keys(modelMap).filter(name => modelMap[name].list && modelMap[name].single);
+}
+// it's dumb but let's leave it for now
+function isArrayOf(type, expected) {
+    if (isOptionalList(type)) {
+        return true;
+    }
+    if (isNonNullType(type) && isOptionalList(type.ofType)) {
+        return true;
+    }
+    function isOptionalList(list) {
+        if (isListType(list)) {
+            if (list.ofType.name === expected.name) {
+                return true;
+            }
+            if (isNonNullType(list.ofType) &&
+                list.ofType.ofType.name === expected.name) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function hasID(type) {
+    return isObjectType(type) && !!type.getFields().id;
+}
+function isNameEqual(a, b) {
+    return convertName(a) === convertName(b);
+}
+function isContextFn(context) {
+    return typeof context === 'function';
+}
+
+function parseVariable({ value, variable, schema, }) {
+    if (isNil(value)) {
+        return;
+    }
+    return resolveVariable$1({
+        value,
+        type: variable.type,
+        schema,
+    });
+}
+function resolveVariable$1({ value, type, schema, }) {
+    if (type.kind === Kind.NAMED_TYPE) {
+        const namedType = schema.getType(type.name.value);
+        if (isScalarType(namedType)) {
+            // GraphQLBoolean.serialize expects a boolean or a number only
+            if (isEqualType(GraphQLBoolean, namedType)) {
+                // we don't support TRUE
+                value = value === 'true';
+            }
+            return namedType.serialize(value);
+        }
+        if (isInputObjectType(namedType)) {
+            return value && typeof value === 'object' ? value : JSON.parse(value);
+        }
+        return value;
+    }
+    if (type.kind === Kind.LIST_TYPE) {
+        return value.map(val => resolveVariable$1({
+            value: val,
+            type: type.type,
+            schema,
+        }));
+    }
+    if (type.kind === Kind.NON_NULL_TYPE) {
+        return resolveVariable$1({
+            value: value,
+            type: type.type,
+            schema,
+        });
+    }
+}
+
+class SubscriptionManager {
+    constructor(sofa) {
+        this.sofa = sofa;
+        this.operations = new Map();
+        this.clients = new Map();
+        this.buildOperations();
+    }
+    start(event, { req, res, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const id = v4();
+            const name = event.subscription;
+            if (!this.operations.has(name)) {
+                throw new Error(`Subscription '${name}' is not available`);
+            }
+            const { document, operationName, variables } = this.operations.get(name);
+            logger.info(`[Subscription] Start ${id}`, event);
+            const result = yield this.execute({
+                id,
+                name,
+                url: event.url,
+                document,
+                operationName,
+                variables,
+                req,
+                res,
+            });
+            if (typeof result !== 'undefined') {
+                return result;
+            }
+            return { id };
+        });
+    }
+    stop(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger.info(`[Subscription] Stop ${id}`);
+            if (!this.clients.has(id)) {
+                throw new Error(`Subscription with ID '${id}' does not exist`);
+            }
+            const execution = this.clients.get(id);
+            if (execution.iterator.return) {
+                execution.iterator.return();
+            }
+            this.clients.delete(id);
+            return { id };
+        });
+    }
+    update(event, { req, res, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { variables, id } = event;
+            logger.info(`[Subscription] Update ${id}`, event);
+            if (!this.clients.has(id)) {
+                throw new Error(`Subscription with ID '${id}' does not exist`);
+            }
+            const { name: subscription, url } = this.clients.get(id);
+            this.stop(id);
+            return this.start({
+                url,
+                subscription,
+                variables,
+            }, {
+                req,
+                res,
+            });
+        });
+    }
+    execute({ id, document, name, url, operationName, variables, req, res, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const variableNodes = this.operations.get(name).variables;
+            const variableValues = variableNodes.reduce((values, variable) => {
+                const value = parseVariable({
+                    value: variables[variable.variable.name.value],
+                    variable,
+                    schema: this.sofa.schema,
+                });
+                if (typeof value === 'undefined') {
+                    return values;
+                }
+                return Object.assign(Object.assign({}, values), { [name]: value });
+            }, {});
+            const C = isContextFn(this.sofa.context)
+                ? yield this.sofa.context({ req, res })
+                : this.sofa.context;
+            const execution = yield subscribe({
+                schema: this.sofa.schema,
+                document,
+                operationName,
+                variableValues,
+                contextValue: C,
+            });
+            if (isAsyncIterable(execution)) {
+                // successful
+                // add execution to clients
+                this.clients.set(id, {
+                    name,
+                    url,
+                    iterator: execution,
+                });
+                // success
+                forAwaitEach(execution, (result) => __awaiter(this, void 0, void 0, function* () {
+                    yield this.sendData({
+                        id,
+                        result,
+                    });
+                })).then(() => {
+                    // completes
+                    this.stop(id);
+                }, e => {
+                    logger.info(`Subscription #${id} closed`);
+                    logger.error(e);
+                    this.stop(id);
+                });
+            }
+            else {
+                return execution;
+            }
+        });
+    }
+    sendData({ id, result }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.clients.has(id)) {
+                throw new Error(`Subscription with ID '${id}' does not exist`);
+            }
+            const { url } = this.clients.get(id);
+            logger.info(`[Subscription] Trigger ${id}`);
+            yield axios.post(url, result);
+        });
+    }
+    buildOperations() {
+        const subscription = this.sofa.schema.getSubscriptionType();
+        if (!subscription) {
+            return;
+        }
+        const fieldMap = subscription.getFields();
+        for (const field in fieldMap) {
+            const document = buildOperation({
+                kind: 'subscription',
+                field,
+                schema: this.sofa.schema,
+                models: this.sofa.models,
+                ignore: this.sofa.ignore,
+            });
+            const { variables, name: operationName } = getOperationInfo(document);
+            this.operations.set(field, {
+                operationName,
+                document,
+                variables,
+            });
+        }
+    }
+}
+
+function createRouter(sofa) {
+    logger.debug('[Sofa] Creating router');
+    const router = Router();
+    const queryType = sofa.schema.getQueryType();
+    const mutationType = sofa.schema.getMutationType();
+    const subscriptionManager = new SubscriptionManager(sofa);
+    if (queryType) {
+        Object.keys(queryType.getFields()).forEach(fieldName => {
+            const route = createQueryRoute({ sofa, router, fieldName });
+            if (sofa.onRoute) {
+                sofa.onRoute(route);
+            }
+        });
+    }
+    if (mutationType) {
+        Object.keys(mutationType.getFields()).forEach(fieldName => {
+            const route = createMutationRoute({ sofa, router, fieldName });
+            if (sofa.onRoute) {
+                sofa.onRoute(route);
+            }
+        });
+    }
+    router.post('/webhook', useAsync((req, res) => __awaiter(this, void 0, void 0, function* () {
+        const { subscription, variables, url } = req.body;
+        try {
+            const result = yield subscriptionManager.start({
+                subscription,
+                variables,
+                url,
+            }, { req, res });
+            res.statusCode = 200;
+            res.statusMessage = 'OK';
+            res.json(result);
+        }
+        catch (e) {
+            res.statusCode = 500;
+            res.statusMessage = 'Subscription failed';
+            res.json(e);
+        }
+    })));
+    router.post('/webhook/:id', useAsync((req, res) => __awaiter(this, void 0, void 0, function* () {
+        const id = req.params.id;
+        const variables = req.body.variables;
+        try {
+            const result = yield subscriptionManager.update({
+                id,
+                variables,
+            }, {
+                req,
+                res,
+            });
+            res.statusCode = 200;
+            res.statusMessage = 'OK';
+            res.json(result);
+        }
+        catch (e) {
+            res.statusCode = 500;
+            res.statusMessage = 'Subscription failed to update';
+            res.json(e);
+        }
+    })));
+    router.delete('/webhook/:id', useAsync((req, res) => __awaiter(this, void 0, void 0, function* () {
+        const id = req.params.id;
+        try {
+            const result = yield subscriptionManager.stop(id);
+            res.statusCode = 200;
+            res.statusMessage = 'OK';
+            res.json(result);
+        }
+        catch (e) {
+            res.statusCode = 500;
+            res.statusMessage = 'Subscription failed to stop';
+            res.json(e);
+        }
+    })));
+    return router;
+}
+function createQueryRoute({ sofa, router, fieldName, }) {
+    logger.debug(`[Router] Creating ${fieldName} query`);
+    const queryType = sofa.schema.getQueryType();
+    const operation = buildOperation({
+        kind: 'query',
+        schema: sofa.schema,
+        field: fieldName,
+        models: sofa.models,
+        ignore: sofa.ignore,
+    });
+    const info = getOperationInfo(operation);
+    const field = queryType.getFields()[fieldName];
+    const fieldType = field.type;
+    const isSingle = isObjectType(fieldType) ||
+        (isNonNullType(fieldType) && isObjectType(fieldType.ofType));
+    const hasIdArgument = field.args.some(arg => arg.name === 'id');
+    const path = getPath(fieldName, isSingle && hasIdArgument);
+    const method = produceMethod({
+        typeName: queryType.name,
+        fieldName,
+        methodMap: sofa.method,
+        defaultValue: 'GET',
+    });
+    router[method.toLocaleLowerCase()](path, useHandler({ info, fieldName, sofa, operation }));
+    logger.debug(`[Router] ${fieldName} query available at ${method} ${path}`);
+    return {
+        document: operation,
+        path,
+        method: method.toUpperCase(),
+    };
+}
+function createMutationRoute({ sofa, router, fieldName, }) {
+    logger.debug(`[Router] Creating ${fieldName} mutation`);
+    const mutationType = sofa.schema.getMutationType();
+    const operation = buildOperation({
+        kind: 'mutation',
+        schema: sofa.schema,
+        field: fieldName,
+        models: sofa.models,
+        ignore: sofa.ignore,
+    });
+    const info = getOperationInfo(operation);
+    const path = getPath(fieldName);
+    const method = produceMethod({
+        typeName: mutationType.name,
+        fieldName,
+        methodMap: sofa.method,
+        defaultValue: 'POST',
+    });
+    router[method.toLowerCase()](path, useHandler({ info, fieldName, sofa, operation }));
+    logger.debug(`[Router] ${fieldName} mutation available at ${method} ${path}`);
+    return {
+        document: operation,
+        path,
+        method: method.toUpperCase(),
+    };
+}
+function useHandler(config) {
+    const { sofa, operation, fieldName } = config;
+    const info = config.info;
+    return useAsync((req, res) => __awaiter(this, void 0, void 0, function* () {
+        const variableValues = info.variables.reduce((variables, variable) => {
+            const name = variable.variable.name.value;
+            const value = parseVariable({
+                value: pickParam(req, name),
+                variable,
+                schema: sofa.schema,
+            });
+            if (typeof value === 'undefined') {
+                return variables;
+            }
+            return Object.assign(Object.assign({}, variables), { [name]: value });
+        }, {});
+        const contextValue = isContextFn(sofa.context)
+            ? yield sofa.context({ req, res })
+            : sofa.context;
+        const result = yield sofa.execute({
+            schema: sofa.schema,
+            source: print(operation),
+            contextValue,
+            variableValues,
+            operationName: info.operation.name && info.operation.name.value,
+        });
+        if (result.errors) {
+            const defaultErrorHandler = (res, errors) => {
+                res.statusCode = 500;
+                res.json(errors[0]);
+            };
+            const errorHandler = sofa.errorHandler || defaultErrorHandler;
+            errorHandler(res, result.errors);
+            return;
+        }
+        res.json(result.data && result.data[fieldName]);
+    }));
+}
+function getPath(fieldName, hasId = false) {
+    return `/${convertName(fieldName)}${hasId ? '/:id' : ''}`;
+}
+function pickParam(req, name) {
+    if (req.params && req.params.hasOwnProperty(name)) {
+        return req.params[name];
+    }
+    if (req.query && req.query.hasOwnProperty(name)) {
+        return req.query[name];
+    }
+    if (req.body && req.body.hasOwnProperty(name)) {
+        return req.body[name];
+    }
+}
+function useAsync(handler) {
+    return (req, res, next) => {
+        Promise.resolve(handler(req, res, next)).catch(e => next(e));
+    };
+}
+function produceMethod({ typeName, fieldName, methodMap, defaultValue, }) {
+    const path = `${typeName}.${fieldName}`;
+    if (methodMap && methodMap[path]) {
+        return methodMap[path];
+    }
+    return defaultValue;
+}
+
+function mapToPrimitive(type) {
+    const formatMap = {
+        Int: {
+            type: 'integer',
+            format: 'int32',
+        },
+        Float: {
+            type: 'number',
+            format: 'float',
+        },
+        String: {
+            type: 'string',
+        },
+        Boolean: {
+            type: 'boolean',
+        },
+        ID: {
+            type: 'string',
+        },
+    };
+    if (formatMap[type]) {
+        return formatMap[type];
+    }
+}
+function mapToRef(type) {
+    return `#/components/schemas/${type}`;
+}
+
+function buildSchemaObjectFromType(type) {
+    const required = [];
+    const properties = {};
+    const fields = type.getFields();
+    for (const fieldName in fields) {
+        const field = fields[fieldName];
+        if (isNonNullType(field.type)) {
+            required.push(field.name);
+        }
+        properties[fieldName] = resolveField$1(field);
+        if (field.description) {
+            properties[fieldName].description = field.description;
+        }
+    }
+    return Object.assign(Object.assign(Object.assign({ type: 'object' }, (required.length ? { required } : {})), { properties }), (type.description ? { description: type.description } : {}));
+}
+function resolveField$1(field) {
+    return resolveFieldType(field.type);
+}
+// array -> [type]
+// type -> $ref
+// scalar -> swagger primitive
+function resolveFieldType(type) {
+    if (isNonNullType(type)) {
+        return resolveFieldType(type.ofType);
+    }
+    if (isListType(type)) {
+        return {
+            type: 'array',
+            items: resolveFieldType(type.ofType),
+        };
+    }
+    if (isObjectType(type)) {
+        return {
+            $ref: mapToRef(type.name),
+        };
+    }
+    if (isScalarType(type)) {
+        return (mapToPrimitive(type.name) || {
+            type: 'object',
+        });
+    }
+    return {
+        type: 'object',
+    };
+}
+
+function buildPathFromOperation({ url, schema, operation, useRequestBody, }) {
+    const info = getOperationInfo(operation);
+    const description = resolveDescription(schema, info.operation);
+    return Object.assign(Object.assign({ operationId: info.name }, (useRequestBody
+        ? {
+            requestBody: {
+                content: {
+                    'application/json': {
+                        schema: resolveRequestBody(info.operation.variableDefinitions),
+                    },
+                },
+            },
+        }
+        : {
+            parameters: resolveParameters(url, info.operation.variableDefinitions),
+        })), { responses: {
+            200: {
+                description,
+                content: {
+                    'application/json': {
+                        schema: resolveResponse({
+                            schema,
+                            operation: info.operation,
+                        }),
+                    },
+                },
+            },
+        } });
+}
+function resolveParameters(url, variables) {
+    if (!variables) {
+        return [];
+    }
+    return variables.map((variable) => {
+        return {
+            in: isInPath(url, variable.variable.name.value) ? 'path' : 'query',
+            name: variable.variable.name.value,
+            required: variable.type.kind === Kind.NON_NULL_TYPE,
+            schema: resolveParamSchema(variable.type),
+        };
+    });
+}
+function resolveRequestBody(variables) {
+    if (!variables) {
+        return {};
+    }
+    const properties = {};
+    const required = [];
+    variables.forEach(variable => {
+        if (variable.type.kind === Kind.NON_NULL_TYPE) {
+            required.push(variable.variable.name.value);
+        }
+        properties[variable.variable.name.value] = resolveParamSchema(variable.type);
+    });
+    return Object.assign({ type: 'object', properties }, (required.length ? { required } : {}));
+}
+// array -> [type]
+// type -> $ref
+// scalar -> swagger primitive
+function resolveParamSchema(type) {
+    if (type.kind === Kind.NON_NULL_TYPE) {
+        return resolveParamSchema(type.type);
+    }
+    if (type.kind === Kind.LIST_TYPE) {
+        return {
+            type: 'array',
+            items: resolveParamSchema(type.type),
+        };
+    }
+    const primitive = mapToPrimitive(type.name.value);
+    return (primitive || {
+        $ref: mapToRef(type.name.value),
+    });
+}
+function resolveResponse({ schema, operation, }) {
+    const operationType = operation.operation;
+    const rootField = operation.selectionSet.selections[0];
+    if (rootField.kind === Kind.FIELD) {
+        if (operationType === 'query') {
+            const queryType = schema.getQueryType();
+            const field = queryType.getFields()[rootField.name.value];
+            return resolveFieldType(field.type);
+        }
+        if (operationType === 'mutation') {
+            const mutationType = schema.getMutationType();
+            const field = mutationType.getFields()[rootField.name.value];
+            return resolveFieldType(field.type);
+        }
+    }
+}
+function isInPath(url, param) {
+    return url.indexOf(`{${param}}`) !== -1;
+}
+function resolveDescription(schema, operation) {
+    const selection = operation.selectionSet.selections[0];
+    const fieldName = selection.name.value;
+    const typeDefinition = schema.getType(titleCase(operation.operation));
+    if (!typeDefinition) {
+        return '';
+    }
+    const definitionNode = typeDefinition.astNode || parse(printType(typeDefinition)).definitions[0];
+    if (!isObjectTypeDefinitionNode(definitionNode)) {
+        return '';
+    }
+    const fieldNode = definitionNode.fields.find(field => field.name.value === fieldName);
+    const descriptionDefinition = fieldNode && fieldNode.description;
+    return descriptionDefinition && descriptionDefinition.value
+        ? descriptionDefinition.value
+        : '';
+}
+function isObjectTypeDefinitionNode(node) {
+    return node.kind === Kind.OBJECT_TYPE_DEFINITION;
+}
+
+function OpenAPI({ schema, info, components, security, }) {
+    const types = schema.getTypeMap();
+    const swagger = {
+        openapi: '3.0.0',
+        info,
+        paths: {},
+        components: {
+            schemas: {},
+        },
+    };
+    for (const typeName in types) {
+        const type = types[typeName];
+        if ((isObjectType(type) || isInputObjectType(type)) &&
+            !isIntrospectionType(type)) {
+            swagger.components.schemas[typeName] = buildSchemaObjectFromType(type);
+        }
+    }
+    if (components) {
+        swagger.components = Object.assign(Object.assign({}, components), swagger.components);
+    }
+    if (security) {
+        swagger.security = security;
+    }
+    return {
+        addRoute(info, config) {
+            const basePath = (config === null || config === void 0 ? void 0 : config.basePath) || '';
+            const path = basePath +
+                info.path.replace(/\:[a-z0-9]+\w/i, param => `{${param.replace(':', '')}}`);
+            if (!swagger.paths[path]) {
+                swagger.paths[path] = {};
+            }
+            swagger.paths[path][info.method.toLowerCase()] = buildPathFromOperation({
+                url: path,
+                operation: info.document,
+                schema,
+                useRequestBody: ['POST', 'PUT', 'PATCH'].includes(info.method),
+            });
+        },
+        get() {
+            return swagger;
+        },
+        save(filepath) {
+            const isJSON = /\.json$/i;
+            const isYAML = /.ya?ml$/i;
+            if (isJSON.test(filepath)) {
+                writeOutput(filepath, JSON.stringify(swagger, null, 2));
+            }
+            else if (isYAML.test(filepath)) {
+                writeOutput(filepath, stringify(swagger, Infinity));
+            }
+            else {
+                throw new Error('We only support JSON and YAML files');
+            }
+        },
+    };
+}
+function writeOutput(filepath, contents) {
+    writeFileSync(filepath, contents, {
+        encoding: 'utf-8',
+    });
+}
+
+function useSofa(config) {
+    return createRouter(createSofa(config));
+}
+
+export default useSofa;
+export { OpenAPI, createSofa, useSofa };