基于ProtoBuf协议消息体的自动化代码生成工具

// 批量文件读取函数
async function batchReadFile(list) {
    let funCache = Object.create({});
    let funcMsgCache = Object.create({});
    let allMsgCache = Object.create({});
    await list.reduce(async (last, next) => {
        const result = await last;
        if (result) {
            funCache = Object.assign(funCache, result.funcMsgCache);
            funcMsgCache = Object.assign(funcMsgCache, result.nested);
            allMsgCache = Object.assign(allMsgCache, result.allMsgCache);
        }
        return await readSignFile(next);
    }, readSignFile(list[0]));
    return {
        funcMsgCache,
        funCache,
        allMsgCache,
    };
}

// 单个文件读取函数
function readSignFile(filePath) {
    return new Promise(resolve => {
        fs.readFile(filePath, (__err, originCode) => {
            const code = iconv.decode(originCode, 'utf-8');
            // 使用正则, 匹配到整个文件所有功能号

            // GET_FUNC_MESSAGE_REG = /@funcid\s+(?<funcid>.+)??[\r|\n][\s|\S]+?@desc\s+(?<desc>.+)??[\r|\n][\s|\S]+?message\s+(?<name>(\w+))[\s|\S]+?{/g;message\s+(?<name>(\w+))[\s|\S]+?{/g;
            let funcMsg = GET_FUNC_MESSAGE_REG.exec(code);

            // GET_ALL_MESSAGE_REG = /message (?<name>(\w+))[\s|\S]+?{(?<content>[\s|\S]+?)}/g;
            let allMsg = GET_ALL_MESSAGE_REG.exec(code);
            while (funcMsg !== null) {
                ...
                funcMsg = GET_FUNC_MESSAGE_REG.exec(code);
            }

            while (allMsg !== null) {
                ...
                allMsg = GET_ALL_MESSAGE_REG.exec(code);
            }

            // 之前第一版全用的是正则匹配，但是发现proto消息体不仅仅只是一个文件，它里面可以引入很多模块
            // 导致其他文件的消息体读取不到， 比较麻烦
            // 这里使用了第三方 protobufjs 库进行读取, 可以很方便地为我们解决这个问题
            root.load(filePath, { keepCase: true }, (err, bufCode) => {
                ...
                if (bufCode) {
                    resolve({
                        nested: bufCode.nested, // 嵌套消息体
                        funcMsgCache,
                        allMsgCache,
                    });
                } else {
                    resolve();
                }
            });
        });
    });
}

function writeProtoFile(main, childlist) {
    return new Promise(async resolve => {
        const fileName = `./proto/${main.name}.js`;
        const filePath = path.resolve(__dirname, fileName);
        await write(filePath, baseProtoModule(main, childlist));
        resolve();
    });
}

// @filename commonModule.js
const { NEED_CHANGE_NUMBER } = require('../resource');

// 这里需要将int32, int62, double, long等等JavaScript不存在的类型转化成number
function isNeedChangeNumber(str) {
    if (NEED_CHANGE_NUMBER.includes(str)) return 'number';
    return str;
}

// 基础的proto模板
function baseProtoModule(main, childList) {
    const result = writeContent(main, childList, 'message', false);
    return `
    const str = \`
      ${result}
    \`;
    module.exports = {
      type: '${main.name}',
      str,
    }
  `;
}
// 基础的type模板
function baseTypeModule(main, childList, allMsgCache) {
    return `
    /** 功能号 ${main.use || main.funcid} */
    ${writeContent(main, childList, 'interface', allMsgCache, true)}
  `;
}
// 返回消息体
function writeContent(main, childList, type, allMsgCache = {}, needExport = false) {
    ...
    return `
    ${messageContent(main, type, allMsgCache, parentExportStr ? 'export default' : '')}
    ${childStr}
  `;
}
// 获取消息体
function messageContent(message, type, allMsgCache, prefix = '') {
    ...
    const mainContent = (fields, split) => `
      ${prefix} ${type} ${message.name} {
      ${createMessageContent(fields, split, allMsgCache)}
    }
    `;
    // 可能存在内嵌枚举类型
    const enumContent = (message, split) => `
      ${prefix} enum ${message.name} {
      ${createEnumContent(message, split)}
    }
  `;
    if (message.fieldsArray) {
        return mainContent(message.fieldsArray, splitComman);
    } else {
        // 如果没有field, 则说明可能是特殊类型, 例如枚举Enum
        return enumContent(message, splitComman);
    }
}
// 创建消息体内容
function createMessageContent(list, split, allMsgCache = {}) {
    let str = ``;
    for (let i = 0; i < list.length; i++) {
        const item = list[i];
        const type = item.type.indexOf('.') >= 0 ? item.type.split('.')[1] : item.type;
        if (split == ',') {
            // 获取消息体content, 以获取注释
            const msgContent = allMsgCache[item.parent.name];
            let note = '';
            if (msgContent) {
                const reg = new RegExp(`${item.name}[\\s|\\S]+?;(?<note>[\\s|\\S]*?\\n)`);
                const getNote = reg.exec(msgContent);
                note = `/** ${getNote && getNote.groups.note.replace(/\/\/|\n|\s/g, '')} */`;
            }
            str += `
        ${note}
        ${item.name}: ${item.rule === 'repeated' ? `Array<${type}>` : isNeedChangeNumber(type)}; \n
      `;
        } else if (split == ';') {
            str += `${item.rule || ''} ${type} ${item.name} = ${item.id}${split} \n`;
        }
    }
    return str;
}
...

// @filename confModule.js

function baseConfModule(apiList) {
    let str = '';
    let importStr = '';
    let hadRequire = {};
    for (let i = 0; i < apiList.length; i++) {
        const apiItem = apiList[i];
        // 由于有些消息体可能是Test.EMsg这样的命名，在之前解析文件的时候已经将realName提取出来，
        // 并注入到apiList中
        if (!hadRequire[apiItem.realName]) {
            hadRequire[apiItem.realName] = true;
            // 自动引入
            importStr += `const ${apiItem.realName.toLocaleLowerCase()} = require('../proto/${apiItem.realName}.js'); \n`;
        }
        // 这里生成配置项， 同parse.ts中的PROTO_MAPPING结构一致
        // 在后续parse.ts中，直接引入conf export出的内容
        // 就可以做到零影响注入了
        str += `[FUNAPI.${apiItem.name.toLocaleUpperCase()}]: method(${apiItem.realName.toLocaleLowerCase()}), \n`;
    }
    return `
    import FUNAPI from './FUNAPI';
    // 提取了parse.ts中的方法， 放在公共的文件，方便复用
    const method = require("../../protocol-method");
    ${importStr}

    function method(xxx) {
      return protobuf(xxx);
    }
    export default {
      ${str}
    }
  `;
}