protobufjs 8.4.2 → 8.5.0

package/index.d.ts

@@ -666,13 +666,16 @@ export class Method extends ReflectionObject {
     requestType: string;
 
     /** Whether requests are streamed or not. */
-    requestStream?: boolean;
+    requestStream?: true;
 
     /** Response type. */
     responseType: string;
 
     /** Whether responses are streamed or not. */
-    responseStream?: boolean;
+    responseStream?: true;
+
+    /** gRPC-style method path. */
+    path: string;
 
     /** Resolved request type. */
     resolvedRequestType: (Type|null);
@@ -1204,6 +1207,9 @@ export class Reader {
     /** Read buffer length. */
     len: number;
 
+    /** Whether to discard unknown fields while decoding. */
+    discardUnknown: boolean;
+
     /**
      * Creates a new reader using the specified buffer.
      * @param buffer Buffer to read from
@@ -1326,6 +1332,9 @@ export class Reader {
     /** Recursion limit. */
     static recursionLimit: number;
 
+    /** Whether readers discard unknown fields while decoding. */
+    static discardUnknown: boolean;
+
     /**
      * Skips the next element of the specified wire type.
      * @param wireType Wire type received
@@ -1453,13 +1462,17 @@ export namespace rpc {
      */
     type ServiceMethodCallback<TRes extends Message<TRes>> = (error: (Error|null), response?: TRes) => void;
 
-    /**
-     * A service method part of a {@link rpc.Service} as created by {@link Service.create}.
-     * @param request Request message or plain object
-     * @param [callback] Node-style callback called with the error, if any, and the response message
-     * @returns Promise if `callback` has been omitted, otherwise `undefined`
-     */
-    type ServiceMethod<TReq extends Message<TReq>, TRes extends Message<TRes>> = (request: (TReq|Properties<TReq>), callback?: rpc.ServiceMethodCallback<TRes>) => Promise<Message<TRes>>;
+    /** A service method part of a {@link rpc.Service} as created by {@link Service.create}. */
+    type ServiceMethod<TReq extends Message<TReq>, TRes extends Message<TRes>> = {
+  (request: TReq|Properties<TReq>, callback: rpc.ServiceMethodCallback<TRes>): void;
+  (request: TReq|Properties<TReq>): Promise<TRes>;
+  readonly name: string;
+  readonly path: string;
+  readonly requestType: string;
+  readonly responseType: string;
+  readonly requestStream: true|undefined;
+  readonly responseStream: true|undefined;
+};
 
     /** An RPC service as returned by {@link Service#create}. */
     class Service extends util.EventEmitter {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "protobufjs",
-  "version": "8.4.2",
+  "version": "8.5.0",
   "versionScheme": "~",
   "description": "Protocol Buffers for JavaScript & TypeScript.",
   "author": "Daniel Wirtz <dcode+protobufjs@dcode.io>",
@@ -26,6 +26,7 @@
     "bench": "node bench",
     "build": "npm run build:bundle && npm run build:types",
     "build:bundle": "gulp --gulpfile scripts/gulpfile.js",
+    "build:tests": "node ./scripts/gentests.js",
     "build:types": "node cli/bin/pbts --main --global protobuf --out index.d.ts src/ && node cli/bin/pbts --main --import \"\\$protobuf=..\" --out ext/descriptor.generated.d.ts ext/descriptor.js && node cli/bin/pbts --main --out ext/textformat.generated.d.ts ext/textformat.js",
     "coverage": "npm run coverage:test && npm run coverage:report",
     "coverage:test": "nyc --silent tape -r ./lib/tape-adapter tests/*.js tests/node/*.js",
@@ -43,7 +44,7 @@
     "test": "npm run test:sources && npm run test:types",
     "test:sources": "tape -r ./lib/tape-adapter tests/*.js tests/node/*.js",
     "test:types": "tsc tests/comp_typescript.ts --target es2019 --module commonjs --types node --lib es2019 --esModuleInterop --strictNullChecks --experimentalDecorators --emitDecoratorMetadata && tsc -p tsconfig.test-types.json",
-    "make": "npm run lint:sources && npm run build && npm run lint:types && node ./scripts/gentests.js && npm test"
+    "make": "npm run lint:sources && npm run build && npm run lint:types && npm run build:tests && npm test"
   },
   "dependencies": {
     "long": "^5.3.2"

package/src/converter.js

@@ -42,7 +42,7 @@ function genValuePartial_fromObject(gen, field, fieldIndex, prop) {
             } gen
             ("}");
         } else gen
-            ("if(typeof d%s!==\"object\")", prop)
+            ("if(!util.isObject(d%s))", prop)
                 ("throw TypeError(%j)", field.fullName + ": object expected")
             ("m%s=types[%i].fromObject(d%s,q+1)", prop, fieldIndex, prop);
     } else {
@@ -109,6 +109,8 @@ converter.fromObject = function fromObject(mtype) {
     var gen = util.codegen(["d", "q"], mtype.name + "$fromObject")
     ("if(d instanceof C)")
         ("return d")
+    ("if(!util.isObject(d))")
+        ("throw TypeError(%j)", mtype.fullName + ": object expected")
     ("if(q===undefined)q=0")
     ("if(q>util.recursionLimit)")
         ("throw Error(\"max depth exceeded\")");
@@ -125,7 +127,7 @@ converter.fromObject = function fromObject(mtype) {
         // Map fields
         if (field.map) { gen
     ("if(d%s){", prop)
-        ("if(typeof d%s!==\"object\")", prop)
+        ("if(!util.isObject(d%s))", prop)
             ("throw TypeError(%j)", field.fullName + ": object expected")
         ("m%s={}", prop)
         ("for(var ks=Object.keys(d%s),i=0;i<ks.length;++i){", prop);

package/src/decoder.js

@@ -186,8 +186,10 @@ function decoder(mtype) {
     // Unknown fields
     gen
         ("r.skipType(%s,q,t)", i ? "u" : "t&7")
-        ("util.makeProp(m,\"$unknowns\",false);")
-        ("(m.$unknowns||(m.$unknowns=[])).push(r.raw(s,r.pos))")
+        ("if(!r.discardUnknown){")
+            ("util.makeProp(m,\"$unknowns\",false);")
+            ("(m.$unknowns||(m.$unknowns=[])).push(r.raw(s,r.pos))")
+        ("}")
     ("}")
     ("if(z!==undefined)")
         ("throw Error(\"missing end group\")");

package/src/method.js

@@ -61,7 +61,7 @@ function Method(name, type, requestType, responseType, requestStream, responseSt
 
     /**
      * Whether requests are streamed or not.
-     * @type {boolean|undefined}
+     * @type {true|undefined}
      */
     this.requestStream = requestStream ? true : undefined; // toJSON
 
@@ -73,10 +73,16 @@ function Method(name, type, requestType, responseType, requestStream, responseSt
 
     /**
      * Whether responses are streamed or not.
-     * @type {boolean|undefined}
+     * @type {true|undefined}
      */
     this.responseStream = responseStream ? true : undefined; // toJSON
 
+    /**
+     * gRPC-style method path.
+     * @type {string}
+     */
+    this.path = "/" + this.name;
+
     /**
      * Resolved request type.
      * @type {Type|null}
@@ -154,6 +160,14 @@ Method.prototype.resolve = function resolve() {
     if (this.resolved)
         return this;
 
+    if (this.parent) {
+        var serviceName = this.parent.fullName;
+        if (serviceName.charAt(0) === ".")
+            serviceName = serviceName.substring(1);
+        this.path = "/" + serviceName + "/" + this.name;
+    } else
+        this.path = "/" + this.name;
+
     this.resolvedRequestType = this.parent.lookupType(this.requestType);
     this.resolvedResponseType = this.parent.lookupType(this.responseType);
 

package/src/namespace.js

@@ -426,14 +426,14 @@ Namespace.prototype.lookup = function lookup(path, filterTypes, parentAlreadyChe
     if (path[0] === "")
         return this.root.lookup(path.slice(1), filterTypes);
 
-    // Early bailout for objects with matching absolute paths
-    var found = this.root._fullyQualifiedObjects && this.root._fullyQualifiedObjects["." + flatPath];
+    // Lookup at this namespace and below
+    var found = this._lookupImpl(path, flatPath);
     if (found && (!filterTypes || filterTypes.indexOf(found.constructor) > -1)) {
         return found;
     }
 
-    // Do a regular lookup at this namespace and below
-    found = this._lookupImpl(path, flatPath);
+    // Fall back to respective absolute path once relative scope has been checked (non-standard)
+    found = this.root._fullyQualifiedObjects && this.root._fullyQualifiedObjects["." + flatPath];
     if (found && (!filterTypes || filterTypes.indexOf(found.constructor) > -1)) {
         return found;
     }

package/src/reader.js

@@ -38,6 +38,12 @@ function Reader(buffer) {
      * @type {number}
      */
     this.len = buffer.length;
+
+    /**
+     * Whether to discard unknown fields while decoding.
+     * @type {boolean}
+     */
+    this.discardUnknown = Reader.discardUnknown;
 }
 
 var create_array = typeof Uint8Array !== "undefined"
@@ -450,6 +456,12 @@ Reader.prototype.skip = function skip(length) {
  */
 Reader.recursionLimit = util.recursionLimit;
 
+/**
+ * Whether readers discard unknown fields while decoding.
+ * @type {boolean}
+ */
+Reader.discardUnknown = false;
+
 /**
  * Skips the next element of the specified wire type.
  * @param {number} wireType Wire type received

package/src/roots.js

@@ -1,5 +1,5 @@
 "use strict";
-module.exports = {};
+module.exports = Object.create(null);
 
 /**
  * Named roots.

package/src/rpc/service.js

@@ -23,10 +23,16 @@ var util = require("../util/minimal");
  * @typedef rpc.ServiceMethod
  * @template TReq extends Message<TReq>
  * @template TRes extends Message<TRes>
- * @type {function}
- * @param {TReq|Properties<TReq>} request Request message or plain object
- * @param {rpc.ServiceMethodCallback<TRes>} [callback] Node-style callback called with the error, if any, and the response message
- * @returns {Promise<Message<TRes>>} Promise if `callback` has been omitted, otherwise `undefined`
+ * @type {{
+ *   (request: TReq|Properties<TReq>, callback: rpc.ServiceMethodCallback<TRes>): void;
+ *   (request: TReq|Properties<TReq>): Promise<TRes>;
+ *   readonly name: string;
+ *   readonly path: string;
+ *   readonly requestType: string;
+ *   readonly responseType: string;
+ *   readonly requestStream: true|undefined;
+ *   readonly responseStream: true|undefined;
+ * }}
  */
 
 /**