Question about old versus new functionality

protobuf.js version: 4.1.2 and 6.8.0

Apologies, but this issue is more of a general question than an actual issue. I'm quite new and trying to understand some differences between an older version of this module and the newest version.

In the version around 4.1.2, I might use a proto file like this:

var protobufjs = require("protobufjs");
var builder = protobufjs.loadProtoFile( "myProtoFile.proto" );
var myThing = builder.build( "myThing" );

I'm struggling to see how to recreate this in the new version. I have run something like this:

let builder = protobufjs.loadSync("myProtoFile.proto");
let myThing = builder["myThing"];

In the new version, I can see my defined message types as elements of the myThing object, but it's not the same as the myThing object created using version 4. Specifically, If I have a message type called NameChange, then this is what the older version looked like:

>myThing.NameChange
{ [Function: Message]
  encode: [Function],
  decode: [Function],
  decodeDelimited: [Function],
  decode64: [Function],
  decodeHex: [Function],
  decodeJSON: [Function] }

such that it is a constructor itself. The new version is an object containing functions.

Obviously I'm kind of at a loss, so if I'm hopelessly misguided, I apologize.

[dcodeIO]

let builder = protobufjs.loadSync("myProtoFile.proto"); // 'root' below

What you get there isn't a builder anymore, but a Root instance. That's the core reflection structure containing all the reflection objects within your proto file. A Root instance also is a Namespace and namespaces have methods to look up Types that then have decode and encode functions, like so:

let myThing = root.lookupType("myThing");

The reason why you can't access myThing as a property directly is that it doesn't start with an upper case letter and thus might conflict with other internal properties (these are all lowercase). If it was MyThing, you'd be able to do root.MyThing as well for convenience.

Other functions there are lookup for any kind of reflection object, lookupEnum for making sure it is an enum etc. The lookupXY functions just additionally assert that the result is of the requested kind, so proper type information can be provided when using TypeScript.

Okay, that actually made some sense (and sorry for the bad example, my types are all capitalized).

So, I think I'm getting closer. Previously, using the builder syntax above, if I wanted to encode a message I might do:

var builder = protobufjs.loadProtoFile( "myProtoFile.proto" );
var MyThing = builder.build( "MyThing" );
var msg = MyThing["NameChange"](payload);

and then to create a buffer

var packet = msg.toBuffer();

---

Now, I'd do something like this?

let Root = protobufjs.loadSync("myProtoFile.proto");
let MyThing = Root.MyThing;
let msg = MyThing.NameChange.encode(payload); // this seems to create a BufferWriter

Then I'd call the bytes function to get a buffer analogous to the toBuffer() method above?

Thanks for the quick response by the way!

[dcodeIO]

Procedure is:

let buffer = MyThing.NameChange.encode(payload).finish();

Internally, a buffered Writer (BufferWriter in node) is used with the finish method slicing the underlying buffer and returning the segment of interest.