protobufjs 8.0.3-experimental → 8.0.4-experimental

package/index.d.ts

@@ -188,12 +188,6 @@ export class Enum extends ReflectionObject {
     /** Reserved ranges, if any. */
     public reserved: (number[]|string)[];
 
-    /**
-     * Resolves value features
-     * @returns `this`
-     */
-    public resolve(): Enum;
-
     /**
      * Constructs an enum from an enum descriptor.
      * @param name Enum name
@@ -906,11 +900,17 @@ export abstract class ReflectionObject {
     /** Unique name within its namespace. */
     public name: string;
 
-    /** Resolved Features. */
-    public _features: any;
+    /** The edition specified for this object.  Only relevant for top-level objects. */
+    public _edition: string;
 
-    /** Unresolved Features. */
-    public _protoFeatures: any;
+    /**
+     * The default edition to use for this object if none is specified.  For legacy reasons,
+     * this is proto2 except in the JSON parsing case where it was proto3.
+     */
+    public _defaultEdition: string;
+
+    /** Resolved Features. */
+    public _features: object;
 
     /** Parent namespace. */
     public parent: (Namespace|null);
@@ -954,8 +954,18 @@ export abstract class ReflectionObject {
      */
     public resolve(): ReflectionObject;
 
-    /** Resolves child features from parent features */
-    public _resolveFeatures(): void;
+    /**
+     * Resolves this objects editions features.
+     * @param edition The edition we're currently resolving for.
+     * @returns `this`
+     */
+    public _resolveFeaturesRecursive(edition: string): ReflectionObject;
+
+    /**
+     * Resolves child features from parent features
+     * @param edition The edition we're currently resolving for.
+     */
+    public _resolveFeatures(edition: string): void;
 
     /**
      * Infers features from legacy syntax that may have been specified differently.
@@ -979,7 +989,7 @@ export abstract class ReflectionObject {
      * @param [ifNotSet] Sets the option only if it isn't currently set
      * @returns `this`
      */
-    public setOption(name: string, value: any, ifNotSet?: boolean): ReflectionObject;
+    public setOption(name: string, value: any, ifNotSet?: (boolean|undefined)): ReflectionObject;
 
     /**
      * Sets a parsed option.
@@ -1003,6 +1013,12 @@ export abstract class ReflectionObject {
      * @returns Class name[, space, full name]
      */
     public toString(): string;
+
+    /**
+     * Converts the edition this object is pinned to for JSON format.
+     * @returns The edition string for JSON representation
+     */
+    public _editionToJSON(): (string|undefined);
 }
 
 /** Reflected oneof. */
@@ -2244,10 +2260,10 @@ export namespace util {
      * @param dst Destination object
      * @param path dot '.' delimited path of the property to set
      * @param value the value to set
-     * @param overWrite whether or not to concatenate the values into an array or overwrite; defaults to false.
+     * @param [ifNotSet] Sets the option only if it isn't currently set
      * @returns Destination object
      */
-    function setProperty(dst: { [k: string]: any }, path: string, value: object, overWrite: boolean): { [k: string]: any };
+    function setProperty(dst: { [k: string]: any }, path: string, value: object, ifNotSet?: (boolean|undefined)): { [k: string]: any };
 
     /** Decorator root (TypeScript). */
     let decorateRoot: Root;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "protobufjs",
-  "version": "8.0.3-experimental",
+  "version": "8.0.4-experimental",
   "versionScheme": "~",
   "description": "Protocol Buffers for JavaScript (& TypeScript).",
   "author": "Daniel Wirtz <dcode+protobufjs@dcode.io>",

package/src/enum.js

@@ -85,21 +85,20 @@ function Enum(name, values, options, comment, comments, valuesOptions) {
 }
 
 /**
- * Resolves value features
- * @returns {Enum} `this`
+ * @override
  */
-Enum.prototype.resolve = function resolve() {
-    ReflectionObject.prototype.resolve.call(this);
+Enum.prototype._resolveFeatures = function _resolveFeatures(edition) {
+    var edition = this._edition || edition;
+    ReflectionObject.prototype._resolveFeatures.call(this, edition);
 
-    for (var key of Object.keys(this._valuesProtoFeatures)) {
+    Object.keys(this._valuesProtoFeatures).forEach(key => {
         var parentFeaturesCopy = Object.assign({}, this._features);
         this._valuesFeatures[key] = Object.assign(parentFeaturesCopy, this._valuesProtoFeatures[key] || {});
-    }
+    });
 
     return this;
 };
 
-
 /**
  * Enum descriptor.
  * @interface IEnum
@@ -117,6 +116,9 @@ Enum.prototype.resolve = function resolve() {
 Enum.fromJSON = function fromJSON(name, json) {
     var enm = new Enum(name, json.values, json.options, json.comment, json.comments);
     enm.reserved = json.reserved;
+    if (json.edition)
+        enm._edition = json.edition;
+    enm._defaultEdition = "proto3";  // For backwards-compatibility.
     return enm;
 };
 
@@ -128,6 +130,7 @@ Enum.fromJSON = function fromJSON(name, json) {
 Enum.prototype.toJSON = function toJSON(toJSONOptions) {
     var keepComments = toJSONOptions ? Boolean(toJSONOptions.keepComments) : false;
     return util.toObject([
+        "edition"       , this._editionToJSON(),
         "options"       , this.options,
         "valuesOptions" , this.valuesOptions,
         "values"        , this.values,

package/src/field.js

@@ -35,7 +35,11 @@ var ruleRe = /^required|optional|repeated$/;
  * @throws {TypeError} If arguments are invalid
  */
 Field.fromJSON = function fromJSON(name, json) {
-    return new Field(name, json.id, json.type, json.rule, json.extend, json.options, json.comment);
+    var field = new Field(name, json.id, json.type, json.rule, json.extend, json.options, json.comment);
+    if (json.edition)
+        field._edition = json.edition;
+    field._defaultEdition = "proto3";  // For backwards-compatibility.
+    return field;
 };
 
 /**
@@ -276,6 +280,7 @@ Field.prototype.setOption = function setOption(name, value, ifNotSet) {
 Field.prototype.toJSON = function toJSON(toJSONOptions) {
     var keepComments = toJSONOptions ? Boolean(toJSONOptions.keepComments) : false;
     return util.toObject([
+        "edition" , this._editionToJSON(),
         "rule"    , this.rule !== "optional" && this.rule || undefined,
         "type"    , this.type,
         "id"      , this.id,
@@ -360,9 +365,12 @@ Field.prototype.resolve = function resolve() {
  * @returns {object} The feature values to override
  */
 Field.prototype._inferLegacyProtoFeatures = function _inferLegacyProtoFeatures(edition) {
-    if (edition) return {};
+    if (edition !== "proto2" && edition !== "proto3") {
+        return;
+    }
 
     var features = {};
+    this.resolve();
     if (this.rule === "required") {
         features.field_presence = "LEGACY_REQUIRED";
     }
@@ -377,6 +385,13 @@ Field.prototype._inferLegacyProtoFeatures = function _inferLegacyProtoFeatures(e
     return features;
 };
 
+/**
+ * @override
+ */
+Field.prototype._resolveFeatures = function _resolveFeatures(edition) {
+    return ReflectionObject.prototype._resolveFeatures.call(this, this._edition || edition);
+};
+
 /**
  * Decorator function as returned by {@link Field.d} and {@link MapField.d} (TypeScript).
  * @typedef FieldDecorator

package/src/namespace.js

@@ -240,6 +240,15 @@ Namespace.prototype.add = function add(object) {
         }
     }
     this.nested[object.name] = object;
+
+    if (!(this instanceof Type || this instanceof Service || this instanceof Enum || this instanceof Field)) {
+        // This is a package or a root namespace.
+        if (!object._edition) {
+            // Make sure that some edition is set if it hasn't already been specified.
+            object._edition = object._defaultEdition;
+        }
+    }
+
     object.onAdd(this);
     return clearCache(this);
 };
@@ -311,6 +320,19 @@ Namespace.prototype.resolveAll = function resolveAll() {
     return this;
 };
 
+/**
+ * @override
+ */
+Namespace.prototype._resolveFeaturesRecursive = function _resolveFeaturesRecursive(edition) {
+    var edition = this._edition || edition;
+
+    ReflectionObject.prototype._resolveFeaturesRecursive.call(this, edition);
+    this.nestedArray.forEach(nested => {
+        nested._resolveFeaturesRecursive(edition);
+    });
+    return this;
+};
+
 /**
  * Recursively looks up the reflection object matching the specified path in the scope of this namespace.
  * @param {string|string[]} path Path to look up

package/src/object.js

@@ -49,14 +49,23 @@ function ReflectionObject(name, options) {
     this.name = name;
 
     /**
-     * Resolved Features.
+     * The edition specified for this object.  Only relevant for top-level objects.
+     * @type {string}
      */
-    this._features = {};
+    this._edition = null;
+
+    /**
+     * The default edition to use for this object if none is specified.  For legacy reasons,
+     * this is proto2 except in the JSON parsing case where it was proto3.
+     * @type {string}
+     */
+    this._defaultEdition = "proto2";
 
     /**
-     * Unresolved Features.
+     * Resolved Features.
+     * @type {object}
      */
-    this._protoFeatures = null;
+    this._features = {};
 
     /**
      * Parent namespace.
@@ -163,25 +172,38 @@ ReflectionObject.prototype.onRemove = function onRemove(parent) {
 ReflectionObject.prototype.resolve = function resolve() {
     if (this.resolved)
         return this;
-    var edition = this.getOption("edition");
-    if ((this instanceof Namespace && edition) || (this.parent && this.parent.resolved)) {
-        this._resolveFeatures();
+    if (this instanceof Root) {
+        this._resolveFeaturesRecursive(this._edition);
         this.resolved = true;
     }
     return this;
 };
 
+/**
+ * Resolves this objects editions features.
+ * @param {string} edition The edition we're currently resolving for.
+ * @returns {ReflectionObject} `this`
+ */
+ReflectionObject.prototype._resolveFeaturesRecursive = function _resolveFeaturesRecursive(edition) {
+    return this._resolveFeatures(this._edition || edition);
+};
+
 /**
  * Resolves child features from parent features
+ * @param {string} edition The edition we're currently resolving for.
  * @returns {undefined}
  */
-ReflectionObject.prototype._resolveFeatures = function _resolveFeatures() {
+ReflectionObject.prototype._resolveFeatures = function _resolveFeatures(edition) {
     var defaults = {};
 
-    var protoFeatures = Object.assign(Object.assign({}, this._protoFeatures), this._inferLegacyProtoFeatures(edition));
+    if (!edition) {
+        throw new Error("Unknown edition for " + this.fullName);
+    }
+
+    var protoFeatures = Object.assign(this.options ? Object.assign({},  this.options.features) : {},
+        this._inferLegacyProtoFeatures(edition));
 
-    var edition = this.getOption("edition");
-    if (this instanceof Namespace && edition) {
+    if (this._edition) {
         // For a namespace marked with a specific edition, reset defaults.
         if (edition === "proto2") {
             defaults = Object.assign({}, proto2Defaults);
@@ -220,7 +242,6 @@ ReflectionObject.prototype._resolveFeatures = function _resolveFeatures() {
  * in older editions.
  * @param {string|undefined} edition The edition this proto is on, or undefined if pre-editions
  * @returns {object} The feature values to override
- * @abstract
  */
 ReflectionObject.prototype._inferLegacyProtoFeatures = function _inferLegacyProtoFeatures(/*edition*/) {
     return {};
@@ -241,14 +262,25 @@ ReflectionObject.prototype.getOption = function getOption(name) {
  * Sets an option.
  * @param {string} name Option name
  * @param {*} value Option value
- * @param {boolean} [ifNotSet] Sets the option only if it isn't currently set
+ * @param {boolean|undefined} [ifNotSet] Sets the option only if it isn't currently set
  * @returns {ReflectionObject} `this`
  */
 ReflectionObject.prototype.setOption = function setOption(name, value, ifNotSet) {
-    if (!ifNotSet || !this.options || this.options[name] === undefined) {
+    if (!this.options)
+        this.options = {};
+    if (name === "features") {
+        if (ifNotSet) {
+            this.options.features = Object.assign(Object.assign({}, value), this.options.features || {});
+        } else {
+            this.options.features = Object.assign(this.options.features || {}, value);
+        }
+    } else if (/^features\./.test(name)) {
+        util.setProperty(this.options, name, value, ifNotSet);
+    } else if (!ifNotSet || this.options[name] === undefined) {
         if (this.getOption(name) !== value) this.resolved = false;
-        (this.options || (this.options = {}))[name] = value;
+        this.options[name] = value;
     }
+
     return this;
 };
 
@@ -289,12 +321,6 @@ ReflectionObject.prototype.setParsedOption = function setParsedOption(name, valu
         parsedOptions.push(newOpt);
     }
 
-
-    if (isFeature) {
-        var features = parsedOptions.find(x => {return Object.prototype.hasOwnProperty.call(x, "features");});
-        this._protoFeatures = features.features || {};
-    }
-
     return this;
 };
 
@@ -323,6 +349,19 @@ ReflectionObject.prototype.toString = function toString() {
     return className;
 };
 
+/**
+ * Converts the edition this object is pinned to for JSON format.
+ * @returns {string|undefined} The edition string for JSON representation
+ */
+ReflectionObject.prototype._editionToJSON = function _editionToJSON() {
+    if (!this._edition || this._edition === "proto3") {
+        // Avoid emitting proto3 since we need to default to it for backwards
+        // compatibility anyway.
+        return undefined;
+    }
+    return this._edition;
+}
+
 // Sets up cyclic dependencies (called in index-light)
 ReflectionObject._configure = function(Root_, Namespace_) {
     Root = Root_;

package/src/parse.js

@@ -86,8 +86,21 @@ function parse(source, root, options) {
 
     var ptr = root;
 
+    var topLevelObjects = [];
+    var topLevelOptions = {};
+
     var applyCase = options.keepCase ? function(name) { return name; } : util.camelCase;
 
+    function resolveFileFeatures() {
+        topLevelObjects.forEach(obj => {
+            obj._edition = edition;
+            Object.keys(topLevelOptions).forEach(opt => {
+                if (obj.getOption(opt) !== undefined) return;
+                obj.setOption(opt, topLevelOptions[opt]);
+            });
+        });
+    }
+
     /* istanbul ignore next */
     function illegal(token, name, insideTryCatch) {
         var filename = parse.filename;
@@ -239,11 +252,6 @@ function parse(source, root, options) {
 
         ptr = ptr.define(pkg);
 
-        var oldEdition = ptr.getOption("edition");
-        if (oldEdition && oldEdition !== edition) {
-            throw new Error("incompatible editions detected in package " + pkg + ": " + edition + " vs " + oldEdition);
-        }
-        ptr.setOption("edition", edition);
         skip(";");
     }
 
@@ -277,10 +285,6 @@ function parse(source, root, options) {
         if (!isProto3 && !isProto2)
             throw illegal(edition, "syntax");
 
-        // Syntax is needed to understand the meaning of the optional field rule
-        // Otherwise the meaning is ambiguous between proto2 and proto3
-        root.setOption("edition", edition);
-
         skip(";");
     }
 
@@ -295,8 +299,6 @@ function parse(source, root, options) {
         if (!supportedEditions.includes(edition))
             throw illegal(edition, "edition");
 
-        root.setOption("edition", edition);
-
         skip(";");
     }
 
@@ -410,6 +412,9 @@ function parse(source, root, options) {
             }
         });
         parent.add(type);
+        if (parent === ptr) {
+            topLevelObjects.push(type);
+        }
     }
 
     function parseField(parent, rule, extend) {
@@ -467,6 +472,9 @@ function parse(source, root, options) {
         } else {
             parent.add(field);
         }
+        if (parent === ptr) {
+            topLevelObjects.push(field);
+        }
     }
 
     function parseGroup(parent, rule) {
@@ -604,6 +612,9 @@ function parse(source, root, options) {
           }
         });
         parent.add(enm);
+        if (parent === ptr) {
+            topLevelObjects.push(enm);
+        }
     }
 
     function parseEnumValue(parent, token) {
@@ -745,6 +756,10 @@ function parse(source, root, options) {
     }
 
     function setOption(parent, name, value) {
+        if (ptr === parent && /^features\./.test(name)) {
+            topLevelOptions[name] = value;
+            return;
+        }
         if (parent.setOption)
             parent.setOption(name, value);
     }
@@ -783,6 +798,9 @@ function parse(source, root, options) {
                 throw illegal(token);
         });
         parent.add(service);
+        if (parent === ptr) {
+            topLevelObjects.push(service);
+        }
     }
 
     function parseMethod(parent, token) {
@@ -926,6 +944,8 @@ function parse(source, root, options) {
         }
     }
 
+    resolveFileFeatures();
+
     parse.filename = null;
     return {
         "package"     : pkg,

package/src/root.js

@@ -36,8 +36,8 @@ function Root(options) {
      */
     this.files = [];
 
-    // Default to proto2 if not specified.
-    this.setOption("edition", "proto2", true);
+    // Default to proto2 if unspecified.
+    this._edition = "proto2";
 }
 
 /**
@@ -51,7 +51,7 @@ Root.fromJSON = function fromJSON(json, root) {
         root = new Root();
     if (json.options)
         root.setOptions(json.options);
-    return root.addJSON(json.nested);
+    return root.addJSON(json.nested).resolveAll();
 };
 
 /**

package/src/service.js

@@ -57,7 +57,10 @@ Service.fromJSON = function fromJSON(name, json) {
             service.add(Method.fromJSON(names[i], json.methods[names[i]]));
     if (json.nested)
         service.addJSON(json.nested);
+    if (json.edition)
+        service._edition = json.edition;
     service.comment = json.comment;
+    service._defaultEdition = "proto3";  // For backwards-compatibility.
     return service;
 };
 
@@ -70,6 +73,7 @@ Service.prototype.toJSON = function toJSON(toJSONOptions) {
     var inherited = Namespace.prototype.toJSON.call(this, toJSONOptions);
     var keepComments = toJSONOptions ? Boolean(toJSONOptions.keepComments) : false;
     return util.toObject([
+        "edition" , this._editionToJSON(),
         "options" , inherited && inherited.options || undefined,
         "methods" , Namespace.arrayToJSON(this.methodsArray, toJSONOptions) || /* istanbul ignore next */ {},
         "nested"  , inherited && inherited.nested || undefined,
@@ -113,6 +117,19 @@ Service.prototype.resolveAll = function resolveAll() {
     return this;
 };
 
+/**
+ * @override
+ */
+Service.prototype._resolveFeaturesRecursive = function _resolveFeaturesRecursive(edition) {
+    var edition = this._edition || edition;
+
+    Namespace.prototype._resolveFeaturesRecursive.call(this, edition);
+    this.methodsArray.forEach(method => {
+        method._resolveFeaturesRecursive(edition);        
+    });
+    return this;
+};
+
 /**
  * @override
  */

package/src/type.js

@@ -234,7 +234,7 @@ function clearCache(type) {
  * @param {IType} json Message type descriptor
  * @returns {Type} Created message type
  */
-Type.fromJSON = function fromJSON(name, json) {
+Type.fromJSON = function fromJSON(name, json, nested) {
     var type = new Type(name, json.options);
     type.extensions = json.extensions;
     type.reserved = json.reserved;
@@ -272,6 +272,9 @@ Type.fromJSON = function fromJSON(name, json) {
         type.group = true;
     if (json.comment)
         type.comment = json.comment;
+    if (json.edition)
+        type._edition = json.edition;
+    type._defaultEdition = "proto3";  // For backwards-compatibility.
     return type;
 };
 
@@ -284,6 +287,7 @@ Type.prototype.toJSON = function toJSON(toJSONOptions) {
     var inherited = Namespace.prototype.toJSON.call(this, toJSONOptions);
     var keepComments = toJSONOptions ? Boolean(toJSONOptions.keepComments) : false;
     return util.toObject([
+        "edition"    , this._editionToJSON(),
         "options"    , inherited && inherited.options || undefined,
         "oneofs"     , Namespace.arrayToJSON(this.oneofsArray, toJSONOptions),
         "fields"     , Namespace.arrayToJSON(this.fieldsArray.filter(function(obj) { return !obj.declaringField; }), toJSONOptions) || {},
@@ -309,6 +313,22 @@ Type.prototype.resolveAll = function resolveAll() {
     return this;
 };
 
+/**
+ * @override
+ */
+Type.prototype._resolveFeaturesRecursive = function _resolveFeaturesRecursive(edition) {
+    var edition = this._edition || edition;
+
+    Namespace.prototype._resolveFeaturesRecursive.call(this, edition);
+    this.oneofsArray.forEach(oneof => {
+        oneof._resolveFeatures(edition);        
+    });
+    this.fieldsArray.forEach(field => {
+        field._resolveFeatures(edition);        
+    });
+    return this;
+};
+
 /**
  * @override
  */

package/src/util.js

@@ -171,10 +171,10 @@ util.decorateEnum = function decorateEnum(object) {
  * @param {Object.<string,*>} dst Destination object
  * @param {string} path dot '.' delimited path of the property to set
  * @param {Object} value the value to set
- * @param {boolean} overWrite whether or not to concatenate the values into an array or overwrite; defaults to false.
+ * @param {boolean|undefined} [ifNotSet] Sets the option only if it isn't currently set
  * @returns {Object.<string,*>} Destination object
  */
-util.setProperty = function setProperty(dst, path, value) {
+util.setProperty = function setProperty(dst, path, value, ifNotSet) {
     function setProp(dst, path, value) {
         var part = path.shift();
         if (part === "__proto__" || part === "prototype") {
@@ -184,6 +184,8 @@ util.setProperty = function setProperty(dst, path, value) {
             dst[part] = setProp(dst[part] || {}, path, value);
         } else {
             var prevValue = dst[part];
+            if (prevValue && ifNotSet)
+                return dst;
             if (prevValue)
                 value = [].concat(prevValue).concat(value);
             dst[part] = value;