@whisklabs/grpc/dist/cjs/parser/parser.js

gRPC generator and http library for typescript

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.parser = void 0;
var comment_1 = require("./comment");
var thrower_1 = require("./thrower");
var tokenizer_1 = require("./tokenizer");
var enums_1 = require("./tokens/enums");
var import_1 = require("./tokens/import");
var message_1 = require("./tokens/message");
var options_1 = require("./tokens/options");
var package_1 = require("./tokens/package");
var service_1 = require("./tokens/service");
var syntax_1 = require("./tokens/syntax");
var utils_1 = require("./utils");
function parse(tokens) {
    var schema = {
        syntax: 3,
        imports: [],
        enums: [],
        messages: [],
        options: {},
        extends: [],
        services: [],
    };
    (0, comment_1.cleanComment)();
    (0, comment_1.setComment)(schema);
    var first = true;
    while (tokens.length > 0) {
        switch ((0, comment_1.next)(tokens)) {
            case 'syntax':
                if (!first) {
                    throw new thrower_1.Thrower('syntax', [['must be on first line', 0]]);
                }
                schema.syntax = (0, syntax_1.ParseSyntax)(tokens);
                break;
            case 'package':
                schema.package = (0, package_1.ParsePackage)(tokens);
                break;
            case 'message':
                schema.messages.push((0, message_1.ParseMessage)(tokens));
                break;
            case 'import':
                schema.imports.push((0, import_1.ParseImport)(tokens));
                break;
            case 'enum':
                schema.enums.push((0, enums_1.ParseEnums)(tokens));
                break;
            case 'option': {
                var _a = (0, options_1.ParseOptions)(tokens), field = _a.field, value = _a.value;
                (0, utils_1.insertOption)(schema.options, field, value);
                break;
            }
            case 'extend':
                schema.extends.push((0, message_1.ParseExtend)(tokens));
                break;
            case 'service':
                schema.services.push((0, service_1.ParseService)(tokens));
                break;
            default:
                throw new thrower_1.Thrower('common', [["Unexpected token: ".concat(tokens[0]), 0]]);
        }
        first = false;
    }
    Extend(schema);
    return schema;
}
function Extend(schema) {
    for (var _i = 0, _a = schema.extends; _i < _a.length; _i++) {
        var ext = _a[_i];
        for (var _b = 0, _c = schema.messages; _b < _c.length; _b++) {
            var msg = _c[_b];
            if (msg.name === ext.name) {
                if (msg.extensions.length === 0) {
                    throw new thrower_1.Thrower('extends', [["".concat(msg.name, " does not have extensions"), 0]]);
                }
                for (var _d = 0, _e = ext.message.fields; _d < _e.length; _d++) {
                    var field = _e[_d];
                    for (var _f = 0, _g = msg.extensions; _f < _g.length; _f++) {
                        var extension = _g[_f];
                        if (field.tag < extension.from || field.tag > extension.to) {
                            throw new thrower_1.Thrower('extends', [["".concat(msg.name, " does not declare ").concat(field.tag, " as an extension number"), 0]]);
                        }
                        msg.fields.push(field);
                    }
                }
            }
        }
    }
}
function parser(buf) {
    var _a = (0, tokenizer_1.tokenizer)(buf.toString()), tokens = _a.tokens, lines = _a.lines, columns = _a.columns;
    try {
        return parse(tokens);
    }
    catch (e) {
        if (e instanceof thrower_1.Thrower) {
            e.addRange(tokens);
            e.addLine(lines[lines.length - tokens.length]);
            e.addColumn(columns[lines.length - tokens.length + e.message[0][1]]);
        }
        throw e;
    }
}
exports.parser = parser;
//# sourceMappingURL=parser.js.map