@whisklabs/grpc/dist/esm/parser/tokens/message.js

gRPC generator and http library for typescript

import { isObject } from '@whisklabs/typeguards';
import { next, writeComment } from '../comment';
import { Thrower } from '../thrower';
import { ch, check, cut, insertOption } from '../utils';
import { isNumber, isText } from '../validators';
import { ParseEnums } from './enums';
import { ParseExtensions } from './extensions';
import { ParseField } from './field';
import { ParseOneOf } from './oneof';
import { ParseOptions } from './options';
import { ParseReserved } from './reserved';
export function ParseExtend(tokens) {
    return {
        name: tokens[1],
        message: ParseMessage(tokens),
    };
}
export function MessageBody(tokens, name) {
    var message = {
        name: name,
        enums: [],
        options: {},
        messages: [],
        fields: [],
        extends: [],
        extensions: [],
        reserved: [],
    };
    writeComment(message);
    while (tokens.length > 0) {
        switch (next(tokens)) {
            case '}':
                tokens.shift();
                writeComment(message);
                CheckReserved(message);
                return message;
            case 'map':
            case 'repeated':
            case 'optional':
            case 'required':
                message.fields.push(ParseField(tokens));
                break;
            case 'enum':
                message.enums.push(ParseEnums(tokens));
                break;
            case 'message':
                message.messages.push(ParseMessage(tokens));
                break;
            case 'extensions':
                message.extensions.push(ParseExtensions(tokens));
                break;
            case 'oneof':
                message.fields = message.fields.concat(ParseOneOf(tokens));
                break;
            case 'extend':
                message.extends.push(ParseExtend(tokens));
                break;
            case ';':
                tokens.shift();
                break;
            case 'reserved':
                message.reserved.push(ParseReserved(tokens));
                break;
            case 'option': {
                var _a = ParseOptions(tokens), field = _a.field, value = _a.value;
                insertOption(message.options, field, value);
                break;
            }
            case undefined:
                continue;
            default:
                message.fields.push(ParseField(tokens, true));
        }
    }
    throw new Thrower('message', [['no close tag "}"', 0]]);
}
function CheckReserved(message) {
    for (var _i = 0, _a = message.reserved; _i < _a.length; _i++) {
        var reserved = _a[_i];
        for (var _b = 0, reserved_1 = reserved; _b < reserved_1.length; _b++) {
            var reserve = reserved_1[_b];
            for (var _c = 0, _d = message.fields; _c < _d.length; _c++) {
                var field = _d[_c];
                if (isText(reserve) && reserve === field.name) {
                    throw new Thrower('reserved', [["Field name \"".concat(field.name, "\" in message \"").concat(message.name, "\" is reserved"), 0]]);
                }
                else if (isNumber(reserve) && reserve === field.tag) {
                    throw new Thrower('reserved', [
                        ["Field \"".concat(field.name, "\" in message \"").concat(message.name, "\" with tag \"").concat(field.tag, "\" is reserved"), 0],
                    ]);
                }
                else if (isObject(reserve) && reserve.from <= field.tag && field.tag <= reserve.to) {
                    throw new Thrower('reserved', [
                        [
                            // eslint-disable-next-line max-len
                            "Field \"".concat(field.name, "\" with tag \"").concat(field.tag, "\" in message \"").concat(message.name, "\" is reserved between ").concat(reserve.from, " to ").concat(reserve.to),
                            0,
                        ],
                    ]);
                }
            }
        }
    }
}
export function ParseMessage(tokens) {
    var len = check({
        type: 'message',
        tokens: [tokens[0], tokens[1], tokens[2], tokens[tokens.indexOf('}')]],
        rules: [ch(['extend', 'message']), ch(isText), ch('{'), ch('}')],
    }).len;
    var _a = cut(tokens, len - 1), messageName = _a[1];
    return MessageBody(tokens, messageName);
}
//# sourceMappingURL=message.js.map