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模塊，的確有點難度。