omelop-json-schema/dist/lib/main.js

解析 ts 的interface 到 omelox-protobuf用的 json格式。

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.parseToJsonSchem = exports.jsonSchemaValidate = void 0;
const path = require("path");
const path_1 = require("path");
const TJS = require("typescript-json-schema");
const Ajv = require("ajv");
const fs = require("fs");
const util = require("util");
const ajv = new Ajv();
function log(...args) {
    console.log(...args);
}
function error(msg, ...args) {
    const str = util.format(msg, ...args);
    console.error(str);
    throw new Error(str);
}
let responseStr = '_Res';
let requestStr = '_Req';
let MergeMessage = false;
/**
 * 校验数据
 * @param schema json schema 结构
 * @param data 校验数据
 */
function jsonSchemaValidate(schema, data) {
    let res = ajv.validate(schema, data);
    if (!res) {
        return JSON.stringify(ajv.errors);
    }
}
exports.jsonSchemaValidate = jsonSchemaValidate;
/**
 * @param baseDir
 * @param reqStr
 * @param resStr
 * @param mergeMessage message 结构放到顶层 (默认的客户端不支持,需要修改客户端)
 */
function parseToJsonSchem(baseDir, reqStr = '_Req', resStr = '_Res', mergeMessage = false) {
    responseStr = resStr;
    requestStr = reqStr;
    MergeMessage = mergeMessage;
    let retObj = { client: {}, server: {} };
    const files = fs.readdirSync(baseDir);
    const tsFilePaths = [];
    files.forEach(val => {
        if (!val.endsWith('.ts')) {
            return;
        }
        tsFilePaths.push((0, path_1.resolve)(baseDir + '/' + val));
    });
    // optionally pass argument to schema generator
    const settings = {
        required: true
    };
    // optionally pass ts compiler options
    const compilerOptions = {
        strictNullChecks: true
    };
    const program = TJS.getProgramFromFiles(tsFilePaths, compilerOptions, baseDir);
    const generator = TJS.buildGenerator(program, settings);
    // all symbols
    const symbols = generator.getMainFileSymbols(program);
    let clientMessages = {};
    let serverMessages = {};
    files.forEach(val => {
        if (!val.endsWith('.ts')) {
            return;
        }
        if (!mergeMessage) {
            clientMessages = {};
            serverMessages = {};
        }
        const obj = parseFile(baseDir, val, program, generator, symbols, clientMessages, serverMessages);
        const tmp = path.parse(val);
        let name = '/' + tmp.name.replace(/\./g, '/');
        retObj.client[name] = obj.client;
        retObj.server[name] = obj.server;
    });
    retObj.client = sortMsg(retObj.client);
    retObj.server = sortMsg(retObj.server);
    return retObj;
}
exports.parseToJsonSchem = parseToJsonSchem;
function sortMsg(obj) {
    let arr = [];
    for (let k in obj) {
        arr.push({ k: k, v: obj[k] });
    }
    arr.sort((a, b) => {
        if (a.k.includes('.')) {
            if (b.k.includes('.')) {
                return a.k > b.k ? 1 : -1;
            }
            return -1;
        }
        if (b.k.includes('.')) {
            return 1;
        }
        return a.k > b.k ? 1 : -1;
    });
    let newObj = {};
    for (let v of arr) {
        newObj[v.k] = v.v;
    }
    return newObj;
}
function parseFile(baseDir, filename, program, generator, symbols, clientMessages, serverMessages) {
    if (!symbols || !symbols.length) {
        return;
    }
    const filePath = path.parse(filename);
    filename = filePath.name.replace(/\./g, '_');
    let symbolClient;
    if (symbols.includes(filename + requestStr)) {
        symbolClient = generator.getSchemaForSymbol(filename + requestStr);
    }
    let client;
    let server;
    if (symbolClient) {
        client = symbolClient;
    }
    let symbolServer;
    if (symbols.includes(filename + responseStr)) {
        if (!client) {
            console.warn('WARNING:', filename, `has ${responseStr} without ${requestStr}`);
        }
        symbolServer = generator.getSchemaForSymbol(filename + responseStr);
    }
    if (!symbolServer) {
        if (client) {
            //   console.warn('WARNING:',filename,`has ${requestStr} without ${responseStr}`);
        }
        if (symbols.includes(filename)) {
            symbolServer = generator.getSchemaForSymbol(filename);
        }
    }
    if (!symbolServer) {
        return { client: client };
    }
    server = symbolServer;
    return { client: client, server: server };
}
//# sourceMappingURL=main.js.map