protobuf.js/cli/targets/proto.js

"use strict";
module.exports = proto_target;

proto_target.private = true;

var protobuf = require("protobufjs");

var Namespace  = protobuf.Namespace,
    Enum       = protobuf.Enum,
    Type       = protobuf.Type,
    Field      = protobuf.Field,
    OneOf      = protobuf.OneOf,
    Service    = protobuf.Service,
    Method     = protobuf.Method,
    types      = protobuf.types,
    util       = protobuf.util;

function underScore(str) {
    return str.substring(0,1)
         + str.substring(1)
               .replace(/([A-Z])(?=[a-z]|$)/g, function($0, $1) { return "_" + $1.toLowerCase(); });
}

var out = [];
var indent = 0;
var first = false;
var syntax = 3;
var maxFieldId = 0x1FFFFFFF; // 2^29 - 1
var maxEnumId = 0x7FFFFFFF; // 2^31 - 1

function proto_target(root, options, callback) {
    if (options) {
        switch (options.syntax) {
            case undefined:
            case "proto3":
            case "3":
                syntax = 3;
                break;
            case "proto2":
            case "2":
                syntax = 2;
                break;
            default:
                return callback(Error("invalid syntax: " + options.syntax));
        }
    }
    indent = 0;
    first = false;
    try {
        buildRoot(root);
        return callback(null, out.join("\n"));
    } catch (err) {
        return callback(err);
    } finally {
        out = [];
        syntax = 3;
    }
}

function push(line) {
    if (line === "")
        out.push("");
    else {
        var ind = "";
        for (var i = 0; i < indent; ++i)
            ind += "    ";
        out.push(ind + line);
    }
}

function escape(str) {
    return str.replace(/[\\"']/g, "\\$&")
              .replace(/\r/g, "\\r")
              .replace(/\n/g, "\\n")
              .replace(/\u0000/g, "\\0"); // eslint-disable-line no-control-regex
}

function value(v) {
    switch (typeof v) {
        case "boolean":
            return v ? "true" : "false";
        case "number":
            return v.toString();
        default:
            return "\"" + escape(String(v)) + "\"";
    }
}

function buildRoot(root) {
    root.resolveAll();
    var pkg = [];
    var ptr = root;
    var repeat = true;
    do {
        var nested = ptr.nestedArray;
        if (nested.length === 1 && nested[0] instanceof Namespace && !(nested[0] instanceof Type || nested[0] instanceof Service)) {
            ptr = nested[0];
            if (ptr !== root)
                pkg.push(ptr.name);
        } else
            repeat = false;
    } while (repeat);
    out.push("syntax = \"proto" + syntax + "\";");
    if (pkg.length)
        out.push("", "package " + pkg.join(".") + ";");

    buildOptions(ptr);
    ptr.nestedArray.forEach(build);
}

function build(object) {
    if (object instanceof Enum)
        buildEnum(object);
    else if (object instanceof Type)
        buildType(object);
    else if (object instanceof Field)
        buildField(object);
    else if (object instanceof OneOf)
        buildOneOf(object);
    else if (object instanceof Service)
        buildService(object);
    else if (object instanceof Method)
        buildMethod(object);
    else
        buildNamespace(object);
}

function buildNamespace(namespace) { // just a namespace, not a type etc.
    push("");
    push("message " + namespace.name + " {");
    ++indent;
    buildOptions(namespace);
    consolidateExtends(namespace.nestedArray).remaining.forEach(build);
    --indent;
    push("}");
}

function buildEnum(enm) {
    push("");
    push("enum " + enm.name + " {");
    buildOptions(enm);
    ++indent; first = true;
    Object.keys(enm.values).forEach(function(name) {
        var val = enm.values[name];
        if (first) {
            push("");
            first = false;
        }
        push(name + " = " + val + ";");
    });
    buildRanges("reserved", enm.reserved, maxEnumId);
    --indent; first = false;
    push("}");
}

function buildRanges(keyword, ranges, max) {
    max = max || maxFieldId;
    if (ranges && ranges.length) {
        var parts = [],
            names = [];
        ranges.forEach(function(range) {
            if (typeof range === "string")
                names.push("\"" + escape(range) + "\"");
            else if (range[0] === range[1])
                parts.push(range[0]);
            else
                parts.push(range[0] + " to " + (range[1] === max ? "max" : range[1]));
        });
        push("");
        if (parts.length)
            push(keyword + " " + parts.join(", ") + ";");
        if (names.length)
            push(keyword + " " + names.join(", ") + ";");
    }
}

function buildType(type) {
    if (type.group)
        return; // built with the sister-field
    push("");
    push("message " + type.name + " {");
    ++indent;
    buildOptions(type);
    type.oneofsArray.forEach(build);
    first = true;
    type.fieldsArray.forEach(build);
    consolidateExtends(type.nestedArray).remaining.forEach(build);
    buildRanges("extensions", type.extensions);
    buildRanges("reserved", type.reserved);
    --indent;
    push("}");
}

function buildField(field, passExtend) {
    if (field.partOf && !field.partOf.isProto3Optional) {
        return;
    }
    if (field.declaringField || field.extend !== undefined && !passExtend) {
        return;
    }
    if (first) {
        first = false;
        push("");
    }
    if (field.resolvedType && field.resolvedType.group) {
        buildGroup(field);
        return;
    }
    var sb = [];
    if (field.map)
        sb.push("map<" + field.keyType + ", " + field.type + ">");
    else if (field.repeated)
        sb.push("repeated", field.type);
    else if (syntax === 2)
        sb.push(field.required ? "required" : "optional", field.type);
    else if (syntax === 3 && field.hasPresence)
        sb.push("optional", field.type);
    else
        sb.push(field.type);
    sb.push(underScore(field.name), "=", field.id);
    var opts = buildFieldOptions(field);
    if (opts)
        sb.push(opts);
    push(sb.join(" ") + ";");
}

function buildGroup(field) {
    push((field.rule || "optional") + " group " + field.resolvedType.name + " = " + field.id + " {");
    ++indent;
    buildOptions(field.resolvedType);
    first = true;
    field.resolvedType.fieldsArray.forEach(function(field) {
        buildField(field);
    });
    --indent;
    push("}");
}

function buildFieldOptions(field) {
    var keys = [];
    if (field.options) {
        keys = Object.keys(field.options);
    }
    var sb = [];
    keys.forEach(function(key) {
        if (key === "proto3_optional" || key === "packed" || key === "features") return;

        var val = field.options[key];
        switch (key) {
            case "default":
                if (syntax === 3)
                    return;
                // skip default (resolved) default values
                if (field.long && !util.longNeq(field.defaultValue, types.defaults[field.type]) || !field.long && field.defaultValue === types.defaults[field.type])
                    return;
                // enum defaults specified as strings are type references and not enclosed in quotes
                if (field.resolvedType instanceof Enum)
                    break;
                // otherwise fallthrough
            default:
                val = value(val);
                break;
        }
        sb.push(key + "=" + val);
    });
    var packable = types.packed[field.resolvedType instanceof Enum ? "int32" : field.type];
    if (packable !== undefined) {
        if (field.packed && syntax === 2) {
            sb.push("packed=true");
        } else if(!field.packed && syntax === 3) {
            sb.push("packed=false");
        }
    }
    return sb.length
        ? "[" + sb.join(", ") + "]"
        : null;
}

function consolidateExtends(nested) {
    var ext = Object.create(null);
    nested = nested.filter(function(obj) {
        if (!(obj instanceof Field) || obj.extend === undefined)
            return true;
        (ext[obj.extend] || (ext[obj.extend] = [])).push(obj);
        return false;
    });
    Object.keys(ext).forEach(function(extend) {
        push("");
        push("extend " + extend + " {");
        ++indent; first = true;
        ext[extend].forEach(function(field) {
            buildField(field, true);
        });
        --indent;
        push("}");
    });
    return {
        remaining: nested
    };
}

function buildOneOf(oneof) {
    if (oneof.isProto3Optional) {
        return;
    }

    push("");
    push("oneof " + underScore(oneof.name) + " {");
    ++indent; first = true;
    oneof.oneof.forEach(function(fieldName) {
        var field = oneof.parent.get(fieldName);
        if (first) {
            first = false;
            push("");
        }
        var opts = buildFieldOptions(field);
        push(field.type + " " + underScore(field.name) + " = " + field.id + (opts ? " " + opts : "") + ";");
    });
    --indent;
    push("}");
}

function buildService(service) {
    push("service " + service.name + " {");
    ++indent;
    service.methodsArray.forEach(build);
    consolidateExtends(service.nestedArray).remaining.forEach(build);
    --indent;
    push("}");
}

function buildMethod(method) {
    push(method.type + " " + method.name + " (" + (method.requestStream ? "stream " : "") + method.requestType + ") returns (" + (method.responseStream ? "stream " : "") + method.responseType + ");");
}

function buildOptions(object, ignore = []) {
    if (!object.options)
        return;
    first = true;
    Object.keys(object.options).forEach(function(key) {
        if (ignore.includes(key) || key === "features") return;
        if (first) {
            first = false;
            push("");
        }
        var val = object.options[key];
        push("option " + key + " = " + JSON.stringify(val) + ";");
    });
}