Graphql实战系列（下）

前情介绍

在《Graphql实战系列（上）》中我们已经完成技术选型，并将graphql桥接到凝胶gels项目中，并动手写了schema，并可以通过 http://localhost:5000/graphql 查看效果。这一节，我们根据数据库表来自动生成基本的查询与更新schema，并能方便的扩展schema，实现我们想要的业务逻辑。

效果图

用navicat在数据库中设计的表

自动生成的graphql测试

设计思路

对象定义在apollo-server中是用字符串来做的，而Query与Mutation只能有一个，而我们的定义又会分散在多个文件中，因此只能先以一定的形式把它们存入数组中，在生成schema前一刻再组合。

业务逻辑模块模板设计：

const customDefs = {
    textDefs: `
        type ReviseResult {
            id: Int
            affectedRows: Int
            status: Int
            message: String
        },
    queryDefs: [],
    mutationDefs: []
}

const customResolvers = {
    Query: {
    },
    Mutation: {
    }
 }
export { customDefs, customResolvers }

schema合并算法

let typeDefs = []
    let dirGraphql = requireDir('../../graphql')        //从手写schema业务模块目录读入文件
    G.L.each(dirGraphql, (item, name) => {
        if (item && item.customDefs && item.customResolvers) {
            typeDefs.push(item.customDefs.textDefs || '')                //合并文本对象定义
            typeDefObj.query = typeDefObj.query.concat(item.customDefs.queryDefs || [])        //合并Query
            typeDefObj.mutation = typeDefObj.mutation.concat(item.customDefs.mutationDefs || [])  //合并Matation
            let { Query, Mutation, ...Other } = item.customResolvers
            Object.assign(resolvers.Query, Query)            //合并resolvers.Query
            Object.assign(resolvers.Mutation, Mutation)        //合并resolvers.Mutation
            Object.assign(resolvers, Other)                    //合并其它resolvers
        }
    })
    //将query与matation查询更新对象由自定义的数组转化成为文本形式
    typeDefs.push(Object.entries(typeDefObj).reduce((total, cur) => {
        return total += `
            type ${G.tools.bigCamelCase(cur[0])} {
                ${cur[1].join('')}
            }
        `
    }, ''))

从数据库表动态生成schema

自动生成内容：

• 一个表一个对象；
• 每个表有两个Query，一是单条查询，二是列表查询；
• 三个Mutation，一是新增，二是更新，三是删除；
• 关联表以上篇中的Book与Author为例，Book中有author_id，会生成一个Author对象；而Author表中会生成一个对象列表[Book]

mysql类型 => graphql 类型转化常量定义

定义一类型转换，不在定义中的默认为String。

const TYPEFROMMYSQLTOGRAPHQL = {
    int: 'Int',
    smallint: 'Int',
    tinyint: 'Int',
    bigint: 'Int',
    double: 'Float',
    float: 'Float',
    decimal: 'Float',
}

从数据库中读取数据表信息

    let dao = new BaseDao()
    let tables = await dao.querySql('select TABLE_NAME,TABLE_COMMENT from information_schema.`TABLES` ' +
        ' where TABLE_SCHEMA = ? and TABLE_TYPE = ? and substr(TABLE_NAME,1,2) <> ? order by ?',
        [G.CONFIGS.dbconfig.db_name, 'BASE TABLE', 't_', 'TABLE_NAME'])

从数据库中读取表字段信息

tables.data.forEach((table) => {
        columnRs.push(dao.querySql('SELECT    `COLUMNS`.COLUMN_NAME,`COLUMNS`.COLUMN_TYPE,`COLUMNS`.IS_NULLABLE,' +
            '`COLUMNS`.CHARACTER_SET_NAME,`COLUMNS`.COLUMN_DEFAULT,`COLUMNS`.EXTRA,' +
            '`COLUMNS`.COLUMN_KEY,`COLUMNS`.COLUMN_COMMENT,`STATISTICS`.TABLE_NAME,' +
            '`STATISTICS`.INDEX_NAME,`STATISTICS`.SEQ_IN_INDEX,`STATISTICS`.NON_UNIQUE,' +
            '`COLUMNS`.COLLATION_NAME ' +
            'FROM information_schema.`COLUMNS` ' +
            'LEFT JOIN information_schema.`STATISTICS` ON ' +
            'information_schema.`COLUMNS`.TABLE_NAME = `STATISTICS`.TABLE_NAME ' +
            'AND information_schema.`COLUMNS`.COLUMN_NAME = information_schema.`STATISTICS`.COLUMN_NAME ' +
            'AND information_schema.`STATISTICS`.table_schema = ? ' +
            'where information_schema.`COLUMNS`.TABLE_NAME = ? and `COLUMNS`.table_schema = ?',
            [G.CONFIGS.dbconfig.db_name, table.TABLE_NAME, G.CONFIGS.dbconfig.db_name]))
    })

几个工具函数

取数据库表字段类型，去除圆括号与长度信息

    getStartTillBracket(str: string) {
        return str.indexOf('(') > -1 ? str.substr(0, str.indexOf('(')) : str
    }

下划线分隔的表字段转化为big camel-case

    bigCamelCase(str: string) {
        return str.split('_').map((al) => {
            if (al.length > 0) {
                return al.substr(0, 1).toUpperCase() + al.substr(1).toLowerCase()
            }
            return al
        }).join('')
    }

下划线分隔的表字段转化为small camel-case

    smallCamelCase(str: string) {
        let strs = str.split('_')
        if (strs.length < 2) {
            return str
        } else {
            let tail = strs.slice(1).map((al) => {
                if (al.length > 0) {
                    return al.substr(0, 1).toUpperCase() + al.substr(1).toLowerCase()
                }
                return al
            }).join('')
            return strs[0] + tail
        }
    }

字段是否以_id结尾，是表关联的标志

不以_id结尾，是正常字段,判断是否为null，处理必填

typeDefObj[table].unshift(`${col['COLUMN_NAME']}: ${typeStr}${col['IS_NULLABLE'] === 'NO' ? '!' : ''}\n`)

以_id结尾，则需要处理关联关系

    //Book表以author_id关联单个Author实体
    typeDefObj[table].unshift(`"""关联的实体"""
        ${G.L.trimEnd(col['COLUMN_NAME'], '_id')}: ${G.tools.bigCamelCase(G.L.trimEnd(col['COLUMN_NAME'], '_id'))}`)
    resolvers[G.tools.bigCamelCase(table)] = {
        [G.L.trimEnd(col['COLUMN_NAME'], '_id')]: async (element) => {
            let rs = await new BaseDao(G.L.trimEnd(col['COLUMN_NAME'], '_id')).retrieve({ id: element[col['COLUMN_NAME']] })
            return rs.data[0]
        }
    }
    //Author表关联Book列表
    let fTable = G.L.trimEnd(col['COLUMN_NAME'], '_id')
    if (!typeDefObj[fTable]) {
        typeDefObj[fTable] = []
    }
    if (typeDefObj[fTable].length >= 2)
        typeDefObj[fTable].splice(typeDefObj[fTable].length - 2, 0, `"""关联实体集合"""${table}s: [${G.tools.bigCamelCase(table)}]\n`)
    else
        typeDefObj[fTable].push(`${table}s: [${G.tools.bigCamelCase(table)}]\n`)
    resolvers[G.tools.bigCamelCase(fTable)] = {
        [`${table}s`]: async (element) => {
            let rs = await new BaseDao(table).retrieve({ [col['COLUMN_NAME']]: element.id})
            return rs.data
        }
    }

生成Query查询

单条查询

    if (paramId.length > 0) {
        typeDefObj['query'].push(`${G.tools.smallCamelCase(table)}(${paramId}!): ${G.tools.bigCamelCase(table)}\n`)
        resolvers.Query[`${G.tools.smallCamelCase(table)}`] = async (_, { id }) => {
            let rs = await new BaseDao(table).retrieve({ id })
            return rs.data[0]
        }
    } else {
        G.logger.error(`Table [${table}] must have id field.`)
    }

列表查询

    let complex = table.endsWith('s') ? (table.substr(0, table.length - 1) + 'z') : (table + 's')
    typeDefObj['query'].push(`${G.tools.smallCamelCase(complex)}(${paramStr.join(', ')}): [${G.tools.bigCamelCase(table)}]\n`)
    resolvers.Query[`${G.tools.smallCamelCase(complex)}`] = async (_, args) => {
        let rs = await new BaseDao(table).retrieve(args)
        return rs.data
    }

生成Mutation查询

    typeDefObj['mutation'].push(`
            create${G.tools.bigCamelCase(table)}(${paramForMutation.slice(1).join(', ')}):ReviseResult
            update${G.tools.bigCamelCase(table)}(${paramForMutation.join(', ')}):ReviseResult
            delete${G.tools.bigCamelCase(table)}(${paramId}!):ReviseResult
        `)
    resolvers.Mutation[`create${G.tools.bigCamelCase(table)}`] = async (_, args) => {
        let rs = await new BaseDao(table).create(args)
        return rs
    }
    resolvers.Mutation[`update${G.tools.bigCamelCase(table)}`] = async (_, args) => {
        let rs = await new BaseDao(table).update(args)
        return rs
    }
    resolvers.Mutation[`delete${G.tools.bigCamelCase(table)}`] = async (_, { id }) => {
        let rs = await new BaseDao(table).delete({ id })
        return rs
    }

项目地址

https://github.com/zhoutk/gels

使用方法

git clone https://github.com/zhoutk/gels
cd gels
yarn
tsc -w
nodemon dist/index.js

然后就可以用浏览器打开链接：http://localhost:5000/graphql 查看效果了。

小结

我只能把大概思路写出来，让大家有个整体的概念，若想很好的理解，得自己把项目跑起来，根据我提供的思想，慢慢的去理解。因为我在编写的过程中还是遇到了不少的难点，这块既要自动化，还要能方便的接受手动编写的schema模块，的确有点难度。