Message Operations

const { Message } = require('google-protobuf');

// Message creation (typically done via generated classes)
class MyMessage extends Message {
  constructor(opt_data) {
    super();
    // Generated constructor logic
  }
}

// Basic instance methods
const messageId = message.getJsPbMessageId();
const array = message.toArray();
const string = message.toString();
const cloned = message.cloneMessage();

/**
 * @constructor
 * Base class for all Protocol Buffer messages
 */

/**
 * @typedef {boolean|number|string} ScalarFieldType
 * @typedef {Array<ScalarFieldType>|Array<Uint8Array>} RepeatedFieldType
 * @typedef {ScalarFieldType|RepeatedFieldType|Uint8Array} AnyFieldType
 */

const { Message } = require('google-protobuf');

// Get field value by field number
const value = Message.getField(message, fieldNumber);

// Get field with default value
const valueWithDefault = Message.getFieldWithDefault(message, fieldNumber, defaultValue);

// Set field value
Message.setField(message, fieldNumber, value);

// Check if field is set
const hasField = Message.getField(message, fieldNumber) != null;

// Boolean fields
const boolValue = Message.getBooleanField(message, fieldNumber);
const boolWithDefault = Message.getBooleanFieldWithDefault(message, fieldNumber, false);

// Floating point fields  
const floatValue = Message.getOptionalFloatingPointField(message, fieldNumber);
const floatWithDefault = Message.getFloatingPointFieldWithDefault(message, fieldNumber, 0.0);

// Proto3 field setters (handle zero values correctly)
Message.setProto3IntField(message, fieldNumber, intValue);
Message.setProto3FloatField(message, fieldNumber, floatValue);
Message.setProto3BooleanField(message, fieldNumber, boolValue);
Message.setProto3StringField(message, fieldNumber, stringValue);
Message.setProto3BytesField(message, fieldNumber, bytesValue);
Message.setProto3EnumField(message, fieldNumber, enumValue);

/**
 * @param {!Message} msg The message
 * @param {number} fieldNumber The field number
 * @param {*=} defaultValue Default value to return
 * @return {*} The field value or default
 */

const { Message } = require('google-protobuf');

// Get repeated field array
const repeatedValues = Message.getRepeatedField(message, fieldNumber);

// Type-specific repeated field access
const repeatedFloats = Message.getRepeatedFloatingPointField(message, fieldNumber);
const repeatedBools = Message.getRepeatedBooleanField(message, fieldNumber);

// Add to repeated field
Message.addToRepeatedField(message, fieldNumber, value);
Message.addToRepeatedField(message, fieldNumber, value, optionalIndex);

// Set entire repeated field
Message.setField(message, fieldNumber, [value1, value2, value3]);

// Example: Working with string arrays
const names = Message.getRepeatedField(message, 1) || [];
Message.addToRepeatedField(message, 1, "New Name");

/**
 * @param {!Message} msg The message
 * @param {number} fieldNumber The field number  
 * @param {*} value Value to add
 * @param {number=} opt_index Optional index to insert at
 */

const { Message } = require('google-protobuf');

// Set oneof field (clears other oneof fields)
Message.setOneofField(message, fieldNumber, oneofArray, value);

// Determine which oneof field is set
const activeCase = Message.computeOneofCase(message, oneofArray);

// Example: Working with oneof fields
const ONEOF_CASES = {
  NAME: 1,
  EMAIL: 2, 
  PHONE: 3,
  NONE: 0
};

// Set email field (clears name and phone)
Message.setOneofField(message, 2, [1, 2, 3], "user@example.com");

// Check which field is active
const activeField = Message.computeOneofCase(message, [1, 2, 3]);
switch (activeField) {
  case 1: console.log("Name is set"); break;
  case 2: console.log("Email is set"); break;
  case 3: console.log("Phone is set"); break;
  case 0: console.log("No field is set"); break;
}

/**
 * @param {!Message} msg The message
 * @param {number} fieldNumber The field number to set
 * @param {!Array<number>} oneof Array of oneof field numbers
 * @param {*} value Value to set
 */

const { Message } = require('google-protobuf');

// Get wrapper field value
const wrapperValue = Message.getWrapperField(message, WrapperConstructor, fieldNumber);
const requiredWrapper = Message.getWrapperField(message, WrapperConstructor, fieldNumber, true);

// Set wrapper field
Message.setWrapperField(message, fieldNumber, value);

// Repeated wrapper fields
const repeatedWrappers = Message.getRepeatedWrapperField(message, WrapperConstructor, fieldNumber);
Message.setRepeatedWrapperField(message, fieldNumber, valueArray);
Message.addToRepeatedWrapperField(message, fieldNumber, value);

// Oneof wrapper fields
Message.setOneofWrapperField(message, fieldNumber, oneofArray, value);

// Example: Working with StringValue wrappers
const { StringValue } = require('./well_known_types_pb');

const stringWrapper = Message.getWrapperField(message, StringValue, 1);
const actualString = stringWrapper ? stringWrapper.getValue() : null;

Message.setWrapperField(message, 1, "Hello World");

/**
 * @param {!Message} msg The message
 * @param {!Function} ctor Wrapper constructor
 * @param {number} fieldNumber The field number
 * @param {boolean=} opt_required Whether field is required
 * @return {?Message} Wrapper message or null
 */

const { Message, Map } = require('google-protobuf');

// Get map field (creates if needed unless noLazyCreate is true)
const mapField = Message.getMapField(message, fieldNumber, false, ValueConstructor);
const existingMap = Message.getMapField(message, fieldNumber, true);

// Work with map field
if (mapField) {
  mapField.set("key1", "value1");
  mapField.set("key2", new ValueConstructor());
  
  const value = mapField.get("key1");
  const hasKey = mapField.has("key2");
  mapField.del("key1");
}

// Example: String to message map
const addressMap = Message.getMapField(message, 5, false, AddressMessage);
if (addressMap) {
  const homeAddress = new AddressMessage();
  homeAddress.setStreet("123 Main St");
  addressMap.set("home", homeAddress);
}

/**
 * @param {!Message} msg The message
 * @param {number} fieldNumber The field number
 * @param {boolean=} noLazyCreate Don't create if missing
 * @param {?Function=} valueCtor Value constructor for message maps
 * @return {?Map} The map field or null
 */

const { Message } = require('google-protobuf');

// Instance methods (typically used on generated classes)
const bytes = message.serializeBinary();
const deserializedMessage = MyMessage.deserializeBinary(bytes);

// Extension serialization support
Message.serializeBinaryExtensions(message, writer, extensions, serializeFn);
Message.readBinaryExtension(message, reader, extensions, getExtFn, setExtFn);

// Example: Full serialization cycle
const originalMessage = new MyMessage();
originalMessage.setName("Test");
originalMessage.setValue(42);

// Serialize
const serializedBytes = originalMessage.serializeBinary();

// Deserialize  
const restoredMessage = MyMessage.deserializeBinary(serializedBytes);
console.log(restoredMessage.getName()); // "Test"
console.log(restoredMessage.getValue()); // 42

const { Message } = require('google-protobuf');

// Message equality
const areEqual = Message.equals(message1, message2);

// Find differences between messages
const differences = Message.difference(message1, message2);

// Clone messages
const shallowClone = Message.clone(message);
const deepClone = Message.cloneMessage(message);
const instanceClone = message.cloneMessage(); // Instance method

// Copy message data
Message.copyInto(sourceMessage, targetMessage);

// Field comparison
const fieldsEqual = Message.compareFields(field1, field2);
const extensionsEqual = Message.compareExtensions(ext1, ext2);

// Example: Message comparison workflow
if (!Message.equals(originalMessage, modifiedMessage)) {
  const diffs = Message.difference(originalMessage, modifiedMessage);
  console.log("Messages differ:", diffs);
  
  // Reset to original
  const restored = Message.cloneMessage(originalMessage);
}

/**
 * @param {?Message} m1 First message
 * @param {?Message} m2 Second message  
 * @return {boolean} Whether messages are equal
 */

const { Message } = require('google-protobuf');

// Convert field lists to objects
const objectList = Message.toObjectList(fieldArray, toObjectFn, includeInstance);

// Convert extensions to object representation
const extensionObj = Message.toObjectExtension(
  message, 
  targetObject, 
  extensions, 
  getExtensionFn, 
  includeInstance
);

// Convert entries to map
const map = Message.toMap(entries, keyMapperFn, valueMapperFn, ValueClass);

// Bytes conversion utilities
const base64String = Message.bytesAsB64(bytesValue);
const uint8Array = Message.bytesAsU8(bytesValue);
const base64List = Message.bytesListAsB64(bytesArray);
const uint8List = Message.bytesListAsU8(bytesArray);

// Example: Convert message field to object array
const addressList = Message.getRepeatedField(message, 3);
const addressObjects = Message.toObjectList(
  addressList, 
  (addr) => addr.toObject(),
  true
);

/**
 * @param {!Array<!Message>} field Array of messages
 * @param {function(!Message, boolean=): !Object} toObjectFn Conversion function
 * @param {boolean=} opt_includeInstance Include message instance
 * @return {!Array<!Object>} Array of objects
 */

const { Message, ExtensionFieldInfo } = require('google-protobuf');

// Get extension value
const extensionValue = message.getExtension(extensionFieldInfo);

// Set extension value  
message.setExtension(extensionFieldInfo, value);

// Working with extension metadata
const fieldNumber = extensionFieldInfo.fieldIndex;
const fieldName = extensionFieldInfo.fieldName;
const isRepeated = extensionFieldInfo.isRepeated;
const constructor = extensionFieldInfo.ctor;

// Example: Using extensions
const myExtension = new ExtensionFieldInfo(
  1001,           // Field number
  {my_extension: 0}, // Field name object
  null,           // No constructor (primitive)
  null,           // No toObject function
  0               // Not repeated
);

message.setExtension(myExtension, "Extension value");
const value = message.getExtension(myExtension);

const { Message } = require('google-protobuf');

// Register message type for deserialization
Message.registerMessageType(messageId, MessageConstructor);

// Example: Register custom message type
Message.registerMessageType('my.package.MyMessage', MyMessage);

/**
 * @param {string} id Message type identifier
 * @param {!Function} constructor Message constructor
 */