infinispan 0.13.0 → 0.15.0

package/lib/protocols.js

@@ -23,6 +23,12 @@
   var INFINITE_LIFESPAN = 0x01, INFINITE_MAXIDLE = 0x02; // Duration flag masks
   var MAGIC = 0xA0;
 
+  /**
+   * Creates decode actions for a key-value pair.
+   * @param {Object} decoderKey Key decoder descriptor.
+   * @param {Object} decoderValue Value decoder descriptor.
+   * @returns {Function} Action function that decodes a key-value pair from a byte buffer.
+   */
   function decodePairActions(decoderKey, decoderValue) {
     return f.actions(
         [
@@ -31,7 +37,7 @@
         ]
         , function(values) {
             if (values.length < 2) {
-              logger.tracef("Not enough to read (not array): %s", values);
+              logger.tracef('Not enough to read (not array): %s', values);
               return undefined;
             }
 
@@ -43,7 +49,7 @@
       [codec.decodeString(), codec.decodeString()],
       function(values) {
         if (values.length < 2) {
-          logger.tracef("Not enough to read (not array): %s", values);
+          logger.tracef('Not enough to read (not array): %s', values);
           return undefined;
         }
 
@@ -57,9 +63,28 @@
   var DECODE_VINT = f.actions([codec.decodeVInt()], codec.lastDecoded);
   var DECODE_SHORT = f.actions([codec.decodeShort()], codec.lastDecoded);
 
+  /**
+   * Checks whether an option is present and truthy.
+   * @param {Object} opts Options object.
+   * @param {string} name Option name to check.
+   * @returns {boolean} True if the option exists and is truthy.
+   */
   function hasOpt(opts, name) { return _.has(opts, name) && f.truthy(opts[name]); }
+  /**
+   * Checks whether the 'previous' option is present and truthy.
+   * @param {Object} opts Options object.
+   * @returns {boolean} True if the 'previous' option exists and is truthy.
+   */
   function hasOptPrev(opts) { return hasOpt(opts, 'previous'); }
 
+  /**
+   * Decodes a timestamp (created/lifespan or lastUsed/maxIdle) from a byte buffer.
+   * @param {number} flags Metadata flags byte.
+   * @param {number} mask Bitmask for infinite duration check.
+   * @param {string[]} headers Header names for the decoded values.
+   * @param {Object} bytebuf Byte buffer to decode from.
+   * @returns {Object|undefined} Object with header-keyed timestamp values, or undefined if not enough data.
+   */
   function decodeTimestamp(flags, mask, headers, bytebuf) {
     var timestamp;
     if (((flags & mask) != mask)) {
@@ -75,10 +100,20 @@
     return _.object(headers, timestamp);
   }
 
+  /**
+   * Creates a decode action for a single value.
+   * @param {Object} decoder Decoder descriptor with fun and obj properties.
+   * @returns {Function} Action function that decodes a single value from a byte buffer.
+   */
   function decodeSingle(decoder) {
     return f.actions([decoder.fun(decoder.obj)], codec.lastDecoded);
   }
 
+  /**
+   * Creates a media decoder descriptor from a media type object.
+   * @param {Object} obj Media type object with a decodeMedia method.
+   * @returns {Object} Decoder descriptor with obj and fun properties.
+   */
   function decoderMedia(obj) {
     return {
       obj: obj
@@ -89,10 +124,21 @@
   var EncodeMixin = (function() {
     var logger = u.logger('encoder');
 
+    var VERSION_BYTE_TO_STRING = {
+      22: '2.2', 25: '2.5', 29: '2.9', 30: '3.0', 31: '3.1', 40: '4.0', 41: '4.1'
+    };
+
     return {
       buildFlags: function (opts) { // TODO: Move out to a Mixin (similar to expiry)
         return hasOptPrev(opts) ? 0x01 : 0;
       },
+      /**
+       * Returns the protocol version as a human-readable string (e.g. '3.1').
+       * @returns {string} Protocol version string.
+       */
+      getVersionString: function() {
+        return VERSION_BYTE_TO_STRING[this.version] || String(this.version);
+      },
       encodeHeader: function (op, topologyId, opts) {
         logger.tracef('Encode operation with topology id %d', topologyId);
         var protocolVersion = this.version;
@@ -110,24 +156,24 @@
             codec.encodeUByte(clientIntelligence),          // basic client intelligence
             codec.encodeVInt(topologyId)                    // client topology id
           ];
-        }
+        };
       },
       encodeKey: function (k) {
         var outer = this;
         return function() {
           return [outer.encodeMediaKey(k)]; // key
-        }
+        };
       },
       encodeQuery: function (q) {
         return function() {
           return [codec.encodeQuery(q)]; // query
-        }
+        };
       },
       encodeKeyVersion: function (k, version) {
         var outer = this;
         return function() {
           return [outer.encodeMediaKey(k), codec.encodeBytes(version)]; // key + version
-        }
+        };
       },
       encodeKeyValue: function (k, v) {
         var outer = this;
@@ -137,7 +183,7 @@
               outer.encodeExpiry(opts),     // lifespan & max idle
               [outer.encodeMediaValue(v)]       // value
           );
-        }
+        };
       },
       encodeKeyValueVersion: function (k, v, version) {
         var outer = this;
@@ -148,7 +194,7 @@
               [codec.encodeBytes(version),      // version
                outer.encodeMediaValue(v)]            // value
           );
-        }
+        };
       },
       encodeMultiKey: function (keys) {
         var outer = this;
@@ -170,7 +216,7 @@
             return [
               outer.encodeMediaKey(pair.key),    // key
               outer.encodeMediaValue(pair.value)   // value
-            ]
+            ];
           });
 
           return f.cat(
@@ -203,6 +249,11 @@
   }());
 
   var ExpiryEncodeMixin = (function() {
+    /**
+     * Parses a duration string into a numeric value and time unit byte.
+     * @param {string|number|undefined} d Duration string (e.g. '1h'), number, or undefined.
+     * @returns {Array} Two-element array of [value, unitByte].
+     */
     function parseDuration(d) {
       if (!f.existy(d)) {
         return [undefined, 7];
@@ -210,17 +261,22 @@
         // Numeric durations only allowed to describe infinite (negative) or default durations (0)
         if (d < 0) return [undefined, 8];
         else if (d == 0) return [undefined, 7];
-        else throw new Error('Positive duration provided without time unit: ' + d);
+        else throw new Error(`Positive duration provided without time unit: ${  d}`);
       } else {
         var splitter = /(\d+)[\s,]*([a-zμ]+)/g;
         var matches = splitter.exec(d);
         if (f.existy(matches))
           return [parseInt(matches[1]), timeUnitToByte(matches[2])];
         else
-          throw new Error('Unknown duration format for ' + d);
+          throw new Error(`Unknown duration format for ${  d}`);
       }
     }
 
+    /**
+     * Converts a time unit string to its protocol byte representation.
+     * @param {string} unit Time unit character (e.g. 's', 'ms', 'h').
+     * @returns {number} Byte value representing the time unit.
+     */
     function timeUnitToByte(unit) {
       switch (unit) {
         case 's': return 0;
@@ -231,7 +287,7 @@
         case 'h': return 5;
         case 'd': return 6;
         default: // TODO: Could it be caught in regular expression?
-          throw new Error('Unknown duration unit in ' + unit);
+          throw new Error(`Unknown duration unit in ${  unit}`);
       }
     }
 
@@ -248,7 +304,7 @@
         }
         return [codec.encodeUByte(0x77)]; // default lifespan & max idle
       }
-    }
+    };
   }());
 
   var DecodeMixin = (function() {
@@ -262,14 +318,14 @@
         codec.decodeUByte()     // topology change marker
         ], function(values) {
           if (values.length < 5) {
-            logger.tracef("Not enough to read (not array): %s", values);
+            logger.tracef('Not enough to read (not array): %s', values);
             return undefined;
           }
 
           return {
             msgId: values[1], opCode: values[2],
             status: values[3], hasNewTopology: values[4] == 1
-          }
+          };
         });
     // var DECODE_VERSIONED = f.actions([codec.decodeFixedBytes(8), codec.decodeObject()],
     //                                  function(values) { return {version: values[0], value: values[1]}; });
@@ -279,7 +335,7 @@
         [codec.decodeVInt(), codec.decodeVInt()],
         function(values) {
           if (values.length < 2) {
-            logger.tracef("Not enough to read (not array): %s", values);
+            logger.tracef('Not enough to read (not array): %s', values);
             return undefined;
           }
 
@@ -289,7 +345,7 @@
         [codec.decodeUByte(), codec.decodeVInt()],
         function(values) {
           if (values.length < 2) {
-            logger.tracef("Not enough to read (not array): %s", values);
+            logger.tracef('Not enough to read (not array): %s', values);
             return undefined;
           }
 
@@ -298,23 +354,43 @@
     var DECODE_HOST_PORT = f.actions([codec.decodeString(), codec.decodeShort()],
                                        function(values) { return {host: values[0], port: values[1]}; });
 
-    var SUCCESS = 0x00, NOT_EXECUTED = 0x01, NOT_FOUND = 0x02, // Status codes
+    var SUCCESS = 0x00, NOT_EXECUTED = 0x01, // Status codes
       SUCCESS_WITH_PREV = 0x03, NOT_EXECUTED_WITH_PREV = 0x04; // Status codes
 
+    /**
+     * Checks whether a status code indicates success.
+     * @param {number} status Response status code.
+     * @returns {boolean} True if status is SUCCESS or SUCCESS_WITH_PREV.
+     */
     function isSuccess(status) {
       return status == SUCCESS || status == SUCCESS_WITH_PREV;
     }
 
+    /**
+     * Checks whether a status code indicates the operation was not executed.
+     * @param {number} status Response status code.
+     * @returns {boolean} True if status is NOT_EXECUTED or NOT_EXECUTED_WITH_PREV.
+     */
     function isNotExecuted(status) {
       return status == NOT_EXECUTED || status == NOT_EXECUTED_WITH_PREV;
     }
 
+    /**
+     * Checks whether a status code includes a previous value.
+     * @param {number} status Response status code.
+     * @returns {boolean} True if status is SUCCESS_WITH_PREV or NOT_EXECUTED_WITH_PREV.
+     */
     function hasPrevious(status) {
       return status == SUCCESS_WITH_PREV || status == NOT_EXECUTED_WITH_PREV;
     }
 
-    function hasError(header) { return header.opCode == 0x50; }
-
+    /**
+     * Decodes a previous value from the byte buffer.
+     * @param {Object} header Response header.
+     * @param {Object} bytebuf Byte buffer to decode from.
+     * @param {Object} decoder Value decoder descriptor.
+     * @returns {Object} Result object with decoded previous value and continue flag.
+     */
     function decodePrev(header, bytebuf, decoder) {
       var decodeActions = decodeSingle(decoder);
       var prev = decodeActions(bytebuf);
@@ -324,6 +400,13 @@
         return {continue: false};
     }
 
+    /**
+     * Decodes an object from the byte buffer on success status.
+     * @param {Object} header Response header with status field.
+     * @param {Object} bytebuf Byte buffer to decode from.
+     * @param {Function} action Decode action function to apply.
+     * @returns {Object} Result object with decoded value and continue flag.
+     */
     function decodeObject(header, bytebuf, action) {
       if (isSuccess(header.status)) {
         var obj = action(bytebuf);
@@ -338,7 +421,7 @@
         try {
           var header = DECODE_HEADER(bytebuf);
           if (f.existy(header)) {
-            logger.tracef("Read header(msgId=%d): opCode=%s, status=%s, hasNewTopology=%d",
+            logger.tracef('Read header(msgId=%d): opCode=%s, status=%s, hasNewTopology=%d',
                           header.msgId, header.opCode, header.status, header.hasNewTopology);
             return {continue: true, result: header};
           }
@@ -365,13 +448,13 @@
         return function(header, bytebuf) {
           var decodeAction = decodeSingle(decoderValue);
           return decodeObject(header, bytebuf, decodeAction);
-        }
+        };
       },
       decodeQuery: function() {
         return function(header, bytebuf) {
           var decodeAction = f.actions([f.partial2(codec.decodeQuery,ProtostreamType.lookupProtostreamTypeById,ProtobufRoot.findRootByTypeName)()],codec.lastDecoded);
           return decodeObject(header, bytebuf, decodeAction);
-        }
+        };
       },
       decodeWithMeta: function() {
         var decoderValue = decoderMedia(this.valueMediaType);
@@ -403,7 +486,7 @@
           }
 
           return {result: undefined, continue: true};
-        }
+        };
       },
       decodePrevOrElse: function(opts, cond, orElse) {
         var decoderValue = decoderMedia(this.valueMediaType);
@@ -415,7 +498,7 @@
                 : {result: undefined, continue: true};
 
           return orElse(header);
-        }
+        };
       },
       decodeCountValues: function() {
         var decoderKey = decoderMedia(this.keyMediaType);
@@ -430,7 +513,7 @@
           }
 
           return {result: pairs, continue: true};
-        }
+        };
       },
       decodeStringPairs: function(header, bytebuf) {
         var count = DECODE_VINT(bytebuf);
@@ -503,9 +586,9 @@
       complete: function(f) {
         return function(header) {
           return {result: f(header), continue: true};
-        }
+        };
       }
-    }
+    };
   }());
 
   var ListenersMixin = (function() {
@@ -517,13 +600,20 @@
         codec.decodeUByte()],       // event is retried
         function(values) {
           if (values.length < 3) {
-            logger.tracef("Not enough to read (not array): %s", values);
+            logger.tracef('Not enough to read (not array): %s', values);
             return undefined;
           }
 
-          return {listenerId: values[0], isCustom: values[1] == 1, isRetried: values[2] == 1}
+          return {listenerId: values[0], isCustom: values[1] == 1, isRetried: values[2] == 1};
         });
 
+    /**
+     * Returns an emit function for custom events or falls back to an alternative emitter.
+     * @param {boolean} isCustom Whether the event uses a custom converter.
+     * @param {Object} decoderBytes Decoder descriptor for byte decoding.
+     * @param {Function} alternativeEmit Fallback emit function factory.
+     * @returns {Function} Emit function that dispatches the event.
+     */
     function emitCustomOr(isCustom, decoderBytes, alternativeEmit) {
       if (isCustom) {
         return function(event, emitter, bytebuf, listenerId) {
@@ -553,6 +643,11 @@
       return alternativeEmit(decoderBytes);
     }
 
+    /**
+     * Creates an emit function that decodes and emits a key-version event.
+     * @param {Object} decoderKey Key decoder descriptor.
+     * @returns {Function} Emit function for key-version events.
+     */
     function emitKeyVersion(decoderKey) {
       return function(event, emitter, bytebuf, listenerId) {
         var decoder = f.actions(
@@ -572,6 +667,11 @@
       };
     }
 
+    /**
+     * Creates an emit function that decodes and emits a key-only event.
+     * @param {Object} decodeFn Decoder descriptor for the key.
+     * @returns {Function} Emit function for key-only events.
+     */
     function emitKey(decodeFn) {
       return function(event, emitter, bytebuf, listenerId) {
         var decodeActions = decodeSingle(decodeFn);
@@ -579,7 +679,7 @@
         logger.tracef('Emit %s event for key=%s', event, key);
         emitter.emit(event, key, listenerId);
         return true;
-      }
+      };
     }
 
     return {
@@ -599,27 +699,40 @@
 
         var steps = [
           codec.encodeString(listenerId),     // listener id
-          codec.encodeUByte(includeState),    // include state
-          codec.encodeUByte(0)                // TODO filter factory name
+          codec.encodeUByte(includeState)     // include state
         ];
 
-        if (_.has(opts, "converterFactory") && _.has(opts.converterFactory, "name")) {
+        // Filter factory
+        if (_.has(opts, 'filterFactory') && _.has(opts.filterFactory, 'name')) {
+          steps.push(codec.encodeString(opts.filterFactory.name));
+          var filterParams = opts.filterFactory.params || [];
+          steps.push(codec.encodeUByte(filterParams.length));
+          filterParams.forEach(function(p) { steps.push(codec.encodeBytesWithLength(p)); });
+        } else {
+          steps.push(codec.encodeUByte(0));
+        }
+
+        // Converter factory
+        if (_.has(opts, 'converterFactory') && _.has(opts.converterFactory, 'name')) {
           steps.push(codec.encodeString(opts.converterFactory.name));
-          steps.push(codec.encodeUByte(0));   // TODO add converter parameter support
+          var converterParams = opts.converterFactory.params || [];
+          steps.push(codec.encodeUByte(converterParams.length));
+          converterParams.forEach(function(p) { steps.push(codec.encodeBytesWithLength(p)); });
         } else {
-          steps.push(codec.encodeUByte(0));   // no converter
+          steps.push(codec.encodeUByte(0));
         }
 
-        steps.push(codec.encodeUByte(0));     // raw data disabled
+        // Raw data
+        steps.push(codec.encodeUByte(hasOpt(opts, 'useRawData') ? 1 : 0));
 
         return function() {
           return steps;
-        }
+        };
       },
       encodeListenerId: function(listenerId) {
         return function() {
           return [codec.encodeString(listenerId)];     // listener id
-        }
+        };
       },
       decodeEvent: function(header, bytebuf, listeners) {
         var common = DECODE_EVENT_COMMON(bytebuf);
@@ -639,7 +752,7 @@
         }
         return true;
       }
-    }
+    };
   }());
 
   var IteratorMixin = (function() { // protocol 2.3+
@@ -650,11 +763,11 @@
          codec.decodeVInt()],             // number of entries
         function(values) {
           if (values.length < 2) {
-            logger.tracef("Not enough to read (not array): %s", values);
+            logger.tracef('Not enough to read (not array): %s', values);
             return undefined;
           }
 
-          return {segments: values[0], count: values[1]}
+          return {segments: values[0], count: values[1]};
         });
     var DECODE_VERSION = f.actions(
         [codec.decodeFixedBytes(8)],
@@ -671,12 +784,12 @@
             codec.encodeVInt(batchSize),  // batch size
             codec.encodeUByte(meta)       // metadata
           ];
-        }
+        };
       },
       encodeIterId: function(iterId) {
         return function() {
           return [codec.encodeString(iterId)];
-        }
+        };
       },
       decodeIterId: function(header, bytebuf, conn) {
         var iterId = DECODE_STRING(bytebuf);
@@ -733,30 +846,35 @@
           }
 
           return {result: [], continue: true};
-        }
+        };
       }
-    }
+    };
   }());
 
   var NoListenerInterestsMixin = (function() {
     return {
-      encodeListenerInterests: function (opts) {
+      encodeListenerInterests: function (_) {
         return [codec.encodeUByte(0x0F)]; // interested in all
       }
-    }
+    };
   }());
 
   var ListenerInterestsMixin = (function() {
     return {
-      encodeListenerInterests: function (opts) {
+      encodeListenerInterests: function (_) {
         return [codec.encodeUByte(0x0F)]; // interested in all
       }
-    }
+    };
   }());
 
   var MediaType = function(mediaType) {
     var mediaCodecs = resolveEncoders(mediaType);
 
+    /**
+     * Resolves encoder and decoder functions for a given media type.
+     * @param {string} mediaType Media type string (e.g. 'application/json').
+     * @returns {Array} Three-element array of [idByte, encoderFn, decoderFn].
+     */
     function resolveEncoders(mediaType) {
       return f.dispatch(
         f.isa('application/json', encoder(2, encoderJson, decoderJson()))
@@ -765,30 +883,64 @@
       )(mediaType);
     }
 
+    /**
+     * Encodes a value as JSON.
+     * @param {*} json Value to encode as JSON.
+     * @returns {Buffer} Encoded JSON bytes.
+     */
     function encoderJson(json) {
       return codec.encodeJSON(json);
     }
 
+    /**
+     * Creates a JSON decoder function.
+     * @returns {Function} Decoder function for JSON values.
+     */
     function decoderJson() {
       return codec.decodeJSON();
     }
 
+    /**
+     * Encodes a value as a string.
+     * @param {string} str String value to encode.
+     * @returns {Buffer} Encoded string bytes.
+     */
     function encoderString(str) {
       return codec.encodeString(str);
     }
 
+    /**
+     * Creates a string decoder function.
+     * @returns {Function} Decoder function for string values.
+     */
     function decoderString() {
       return codec.decodeString();
     }
 
+    /**
+     * Encodes a value as Protobuf.
+     * @param {Object} message Protobuf message to encode.
+     * @returns {Buffer} Encoded Protobuf bytes.
+     */
     function encoderProtobuf(message){
       return codec.encodeProtobuf(message,ProtostreamType.lookupProtostreamTypeByName);
     }
 
+    /**
+     * Creates a Protobuf decoder function.
+     * @returns {Function} Decoder function for Protobuf values.
+     */
     function decoderProtobuf(){
       return f.partial2(codec.decodeProtobuf,ProtostreamType.lookupProtostreamTypeById,ProtobufRoot.findRootByTypeName)();
     }
 
+    /**
+     * Creates a media type encoder tuple with id, encoder, and decoder.
+     * @param {number} id Media type identifier byte.
+     * @param {Function} mediaEncoder Encoder function for this media type.
+     * @param {Function} mediaDecoder Decoder function for this media type.
+     * @returns {Function} Factory function returning [id, encoder, decoder] array.
+     */
     function encoder(id, mediaEncoder, mediaDecoder) {
       return function() {
         return [
@@ -796,7 +948,7 @@
           , mediaEncoder
           , mediaDecoder
         ];
-      }
+      };
     }
 
     return {
@@ -817,7 +969,7 @@
 
   var NoMediaTypesMixin = (function() {
     return {
-      init: function(clientOpts) {
+      init: function(_) {
         this.keyMediaType = new MediaType('text/plain');
         this.valueMediaType = new MediaType('text/plain');
       },
@@ -830,10 +982,15 @@
       encodeMediaValue: function(v) {
         return codec.encodeString(v);
       }
-    }
+    };
   }());
 
   var MediaTypesMixin = (function() {
+    /**
+     * Encodes a media type into protocol bytes.
+     * @param {Object} mediaType MediaType instance to encode.
+     * @returns {Array} Array of encoded media type bytes.
+     */
     function encodeMediaType(mediaType) {
       return [
         codec.encodeUByte(1)
@@ -842,6 +999,11 @@
       ];
     }
 
+    /**
+     * Decodes a server media type from the byte buffer.
+     * @param {Object} bytebuf Byte buffer to decode from.
+     * @returns {Object} Result object with continue flag.
+     */
     function decodeServerMediaType(bytebuf) {
       var mediaType = DECODE_UBYTE(bytebuf);
       if (!f.existy(mediaType))
@@ -860,7 +1022,7 @@
     
     return {
       init: function(clientOpts) {
-        logger.debugf("Before init, key media type was: %s"
+        logger.debugf('Before init, key media type was: %s'
           , f.existy(this.keyMediaType) ? this.keyMediaType.getMediaType() : 'undefined'
         );
 
@@ -868,7 +1030,7 @@
         this.valueMediaType = new MediaType(clientOpts.dataFormat.valueType);
         this.authOpts = clientOpts.authentication;
 
-        logger.debugf("After init, key media type is: %s"
+        logger.debugf('After init, key media type is: %s'
           , f.existy(this.keyMediaType) ? this.keyMediaType.getMediaType() : 'undefined'
         );
       },
@@ -899,7 +1061,7 @@
         }
         return {continue: false};
       }
-    }
+    };
   }());
 
   var SASLMixin = (function() {
@@ -913,7 +1075,7 @@
           if (f.existy(authMech)) {
             authMechs.push(authMech);
           } else {
-            return {result: 'Unexpected error decoding auth mechanism ' + i, continue: false};
+            return {result: `Unexpected error decoding auth mechanism ${  i}`, continue: false};
           }
         }
         logger.tracef(authMechs);
@@ -938,7 +1100,7 @@
               response = '';
             }
           } else {
-            logger.tracef("SASL server challenge response [%s]", holder.mech.name);
+            logger.tracef('SASL server challenge response [%s]', holder.mech.name);
             response = holder.mech.challenge(holder.challenge).response({
               username: authOpts.userName, 
               password: authOpts.password, 
@@ -948,36 +1110,36 @@
               host: 'infinispan'
             });
           }
-          logger.tracef("SASL client response [%s]", holder.mech.name);
+          logger.tracef('SASL client response [%s]', holder.mech.name);
           return [codec.encodeString(authOpts.saslMechanism), codec.encodeString(response)];
-        }
+        };
       },
       decodeSasl: function(header, bytebuf) {
         var authDone = DECODE_UBYTE(bytebuf);
         if(authDone == 1) {
           logger.tracef('SASL authentication complete');
-          return {result:  {response: DECODE_UBYTE(bytebuf)}, continue: true};
+          return {result:  {response: DECODE_UBYTE(bytebuf), complete: true}, continue: true};
         } else {
-          return {result:  {response: DECODE_STRING(bytebuf)}, continue: true};
+          return {result:  {response: DECODE_STRING(bytebuf), complete: false}, continue: true};
         }
       }
-    }
+    };
   }());
 
   var Ping29Mixin = (function() {
     return {
       decodePingResponse: function(header,bytebuf){
-        logger.debugf("header and bytebuf %s %s",header,bytebuf);
+        logger.debugf('header and bytebuf %s %s',header,bytebuf);
         return MediaTypesMixin.decodeServerMediaTypes(header,bytebuf);
       }
-    }
+    };
   }());
 
   var Ping30Mixin = (function() {
     return {
       decodePingResponse: function(header,bytebuf){
         var serverMediaTypes= MediaTypesMixin.decodeServerMediaTypes(header,bytebuf);
-        var version=DECODE_UBYTE(bytebuf);
+        DECODE_UBYTE(bytebuf);
         var opCount=DECODE_VINT(bytebuf);
         var opRequestCodes=[];
         for(let i=0;i<opCount;i++){
@@ -985,7 +1147,242 @@
         }
         return serverMediaTypes;
       }
+    };
+  }());
+
+  var CounterMixin = (function() {
+    var DECODE_LONG = f.actions([codec.decodeLong()], codec.lastDecoded);
+
+    // Counter status codes
+    var COUNTER_SUCCESS = 0x00;
+    var COUNTER_NOT_DEFINED = 0x02;
+
+    /**
+     * Encodes only the counter name as the request body.
+     * @param {string} name Counter name.
+     * @returns {Function} Body encoder function.
+     */
+    function encodeCounterName(name) {
+      return function() {
+        return [codec.encodeString(name)];
+      };
+    }
+
+    /**
+     * Encodes a counter name followed by a long value.
+     * @param {string} name Counter name.
+     * @param {number} value Long value.
+     * @returns {Function} Body encoder function.
+     */
+    function encodeCounterNameValue(name, value) {
+      return function() {
+        return [codec.encodeString(name), codec.encodeLong(value)];
+      };
+    }
+
+    /**
+     * Encodes a counter name followed by two long values (expect, update).
+     * @param {string} name Counter name.
+     * @param {number} expect Expected value.
+     * @param {number} update New value.
+     * @returns {Function} Body encoder function.
+     */
+    function encodeCounterNameTwoLongs(name, expect, update) {
+      return function() {
+        return [codec.encodeString(name), codec.encodeLong(expect), codec.encodeLong(update)];
+      };
+    }
+
+    /**
+     * Encodes a counter create request body (name + configuration).
+     * @param {string} name Counter name.
+     * @param {Object} config Counter configuration.
+     * @returns {Function} Body encoder function.
+     */
+    function encodeCounterCreate(name, config) {
+      return function() {
+        var isWeak = config.type === 'weak';
+        var isBounded = config.type === 'strong' && (typeof config.lowerBound === 'number' || typeof config.upperBound === 'number');
+        var isPersistent = config.storage === 'persistent';
+        var flags = (isWeak ? 0x01 : 0x00)
+                  | (isBounded ? 0x02 : 0x00)
+                  | (isPersistent ? 0x04 : 0x00);
+
+        var steps = [
+          codec.encodeString(name),
+          codec.encodeUByte(flags)
+        ];
+
+        if (isWeak) {
+          steps.push(codec.encodeVInt(config.concurrencyLevel || 16));
+        }
+
+        if (isBounded) {
+          steps.push(codec.encodeLong(typeof config.lowerBound === 'number' ? config.lowerBound : 0));
+          steps.push(codec.encodeLong(typeof config.upperBound === 'number' ? config.upperBound : 0));
+        }
+
+        steps.push(codec.encodeLong(config.initialValue || 0));
+
+        return steps;
+      };
+    }
+
+    /**
+     * Decodes a counter long value from the response.
+     * @param {Object} header Response header.
+     * @param {Object} bytebuf Byte buffer to decode from.
+     * @returns {Object} Result object with decoded long value.
+     */
+    function decodeCounterValue(header, bytebuf) {
+      if (header.status === COUNTER_SUCCESS) {
+        var value = DECODE_LONG(bytebuf);
+        if (!f.existy(value) && value !== 0)
+          return {continue: false};
+        return {result: value, continue: true};
+      }
+      if (header.status === COUNTER_NOT_DEFINED)
+        return {result: undefined, continue: true};
+      // Status 0x04 = boundary reached — still has a value
+      if (header.status === 0x04) {
+        var boundValue = DECODE_LONG(bytebuf);
+        if (!f.existy(boundValue) && boundValue !== 0)
+          return {continue: false};
+        return {result: boundValue, continue: true};
+      }
+      return {result: undefined, continue: true};
     }
+
+    /**
+     * Decodes a counter configuration from the response.
+     * @param {Object} header Response header.
+     * @param {Object} bytebuf Byte buffer to decode from.
+     * @returns {Object} Result object with decoded configuration.
+     */
+    function decodeCounterConfig(header, bytebuf) {
+      if (header.status !== COUNTER_SUCCESS)
+        return {result: undefined, continue: true};
+
+      var flags = DECODE_UBYTE(bytebuf);
+      if (!f.existy(flags))
+        return {continue: false};
+
+      var isWeak = (flags & 0x01) !== 0;
+      var isBounded = (flags & 0x02) !== 0;
+      var isPersistent = (flags & 0x04) !== 0;
+
+      var config = {
+        type: isWeak ? 'weak' : 'strong',
+        storage: isPersistent ? 'persistent' : 'volatile'
+      };
+
+      if (isWeak) {
+        var concurrencyLevel = DECODE_VINT(bytebuf);
+        if (!f.existy(concurrencyLevel))
+          return {continue: false};
+        config.concurrencyLevel = concurrencyLevel;
+      }
+
+      if (isBounded) {
+        var lowerBound = DECODE_LONG(bytebuf);
+        if (!f.existy(lowerBound) && lowerBound !== 0)
+          return {continue: false};
+        config.lowerBound = lowerBound;
+
+        var upperBound = DECODE_LONG(bytebuf);
+        if (!f.existy(upperBound) && upperBound !== 0)
+          return {continue: false};
+        config.upperBound = upperBound;
+      }
+
+      var initialValue = DECODE_LONG(bytebuf);
+      if (!f.existy(initialValue) && initialValue !== 0)
+        return {continue: false};
+      config.initialValue = initialValue;
+
+      return {result: config, continue: true};
+    }
+
+    /**
+     * Decodes a success/failure status for counter operations.
+     * @param {Object} header Response header.
+     * @returns {Object} Result object with boolean success.
+     */
+    function decodeCounterStatus(header) {
+      return {result: header.status === COUNTER_SUCCESS, continue: true};
+    }
+
+    return {
+      encodeCounterCreate: encodeCounterCreate,
+      encodeCounterName: encodeCounterName,
+      encodeCounterNameValue: encodeCounterNameValue,
+      encodeCounterNameTwoLongs: encodeCounterNameTwoLongs,
+      decodeCounterValue: decodeCounterValue,
+      decodeCounterConfig: decodeCounterConfig,
+      decodeCounterStatus: decodeCounterStatus
+    };
+  }());
+
+  /**
+   * Protocol 4.0+ requires an 'otherParams' map after media types in the header.
+   * This mixin overrides stepsHeader to append the count (0 = no params).
+   */
+  var OtherParamsMixin = {
+    stepsHeader: function(ctx, op, opts) {
+      var header = this.encodeHeader(op, ctx.topologyId, opts)(ctx.id);
+      var mediaType = this.encodeMediaTypes();
+      return f.cat(header, mediaType, [codec.encodeVInt(0)]);
+    }
+  };
+
+  var DecodePrevWithMetaMixin = (function() {
+    /**
+     * Decodes a previous value with metadata from the response buffer.
+     * @param {Object} header - Response header.
+     * @param {Object} bytebuf - Byte buffer to decode from.
+     * @param {Function} decoderValue - Value decoder function.
+     * @returns {Object} Result object with decoded previous value and metadata.
+     */
+    function decodePrevWithMeta(header, bytebuf, decoderValue) {
+      var flags = DECODE_UBYTE(bytebuf);
+      if (!f.existy(flags))
+        return {continue: false};
+
+      var lifespan = decodeTimestamp(flags, INFINITE_LIFESPAN, ['created', 'lifespan'], bytebuf);
+      if (!f.existy(lifespan))
+        return {continue: false};
+
+      var idle = decodeTimestamp(flags, INFINITE_MAXIDLE, ['lastUsed', 'maxIdle'], bytebuf);
+      if (!f.existy(idle))
+        return {continue: false};
+
+      var decoder = f.actions(
+        [codec.decodeFixedBytes(8), decoderValue.fun(decoderValue.obj)]
+        , function(values) {
+            return {version: values[0], value: values[1]};
+        });
+      var versioned = decoder(bytebuf);
+      if (f.existy(versioned)) {
+        var result = f.merge(versioned, lifespan, idle);
+        return {result: _.isEmpty(result.value) ? undefined : result, continue: true};
+      }
+      return {continue: false};
+    }
+
+    return {
+      decodePrevOrElse: function(opts, cond, orElse) {
+        var decoderValue = decoderMedia(this.valueMediaType);
+        var shouldReturnPrev = hasOptPrev(opts);
+        return function(header, bytebuf) {
+          if (shouldReturnPrev)
+            return cond(header)
+                ? decodePrevWithMeta(header, bytebuf, decoderValue)
+                : {result: undefined, continue: true};
+
+          return orElse(header);
+        };
+      }
+    };
   }());
 
   var ProtostreamType = (function() {
@@ -1001,15 +1398,15 @@
       },
       lookupProtostreamTypeByName: function (protostreamTypeName) {
         return _.find(protostreamTypes,function(protostreamType){
-          return _.isEqual(protostreamType.protostreamTypeName,protostreamTypeName)
+          return _.isEqual(protostreamType.protostreamTypeName,protostreamTypeName);
         }).protostreamDescriptorId;
       },
       lookupProtostreamTypeById: function(protostreamDescriptorId){
         return _.find(protostreamTypes,function(protostreamType){
-          return _.isEqual(protostreamType.protostreamDescriptorId,protostreamDescriptorId)
+          return _.isEqual(protostreamType.protostreamDescriptorId,protostreamDescriptorId);
         }).protostreamTypeName;
       }
-    }
+    };
   }());
 
   var ProtobufRoot = (function() {
@@ -1024,13 +1421,20 @@
           var root= protobufRoot.lookupType(typeName);
           return root;
         }catch(err){
-          throw new Error("Protobuf root not found");
+          throw new Error('Protobuf root not found');
         }
       }
-    }
+    };
   }());
   
 
+  /**
+   * Constructs a Hot Rod protocol instance for the given version.
+   * @param {number} v Protocol version number.
+   * @param {Object} clientOpts Client options.
+   * @constructs Protocol
+   * @returns {void}
+   */
   function Protocol(v, clientOpts) {
     this.version = v;
     this.clientOpts = clientOpts;
@@ -1055,11 +1459,23 @@
     Protocol.call(this, 30, clientOpts);
   };
 
+  var Protocol31 = function(clientOpts) {
+    Protocol.call(this, 31, clientOpts);
+  };
+
+  var Protocol40 = function(clientOpts) {
+    Protocol.call(this, 40, clientOpts);
+  };
+
+  var Protocol41 = function(clientOpts) {
+    Protocol.call(this, 41, clientOpts);
+  };
+
   // TODO: Missing operations, just for reference
   var IdsMixin = {
-    queryId: function() { return 0x1F },
-    authMechId: function() { return 0x21 },
-    authReqId: function() { return 0x23 }
+    queryId: function() { return 0x1F; },
+    authMechId: function() { return 0x21; },
+    authReqId: function() { return 0x23; }
   };
 
   _.extend(Protocol22.prototype
@@ -1122,14 +1538,61 @@
     , Ping30Mixin
     , ProtostreamType
     , ProtobufRoot
-    // TODO 2.6 new ops: getStream and putStream
-    // TODO 2.6 add listener change: listener event interests
-    // TODO 2.7 new ops: prepare, commit and rollback
-    // TODO 2.7 new ops: counter operations
-    // TODO 2.7 new events: counter events
-    // TODO 2.8 listener events: can come from any connection
-    // TODO 2.8 header change: media types
-);
+  );
+
+  _.extend(Protocol31.prototype
+    , EncodeMixin
+    , ExpiryEncodeMixin
+    , DecodeMixin
+    , IdsMixin
+    , ListenersMixin
+    , ListenerInterestsMixin
+    , IteratorMixin
+    , MediaTypesMixin
+    , SASLMixin
+    , Ping30Mixin
+    , CounterMixin
+    , ProtostreamType
+    , ProtobufRoot
+    // TODO 3.1 new ops: bloom filter near-cache
+  );
+
+  _.extend(Protocol40.prototype
+    , EncodeMixin
+    , ExpiryEncodeMixin
+    , OtherParamsMixin
+    , DecodeMixin
+    , DecodePrevWithMetaMixin
+    , IdsMixin
+    , ListenersMixin
+    , ListenerInterestsMixin
+    , IteratorMixin
+    , MediaTypesMixin
+    , SASLMixin
+    , Ping30Mixin
+    , CounterMixin
+    , ProtostreamType
+    , ProtobufRoot
+  );
+
+  _.extend(Protocol41.prototype
+    , EncodeMixin
+    , ExpiryEncodeMixin
+    , OtherParamsMixin
+    , DecodeMixin
+    , DecodePrevWithMetaMixin
+    , IdsMixin
+    , ListenersMixin
+    , ListenerInterestsMixin
+    , IteratorMixin
+    , MediaTypesMixin
+    , SASLMixin
+    , Ping30Mixin
+    , CounterMixin
+    , ProtostreamType
+    , ProtobufRoot
+    // TODO 4.1 new ops: chunked streaming (GetStreamStart/Next/End, PutStreamStart/Next/End)
+  );
 
   exports.version22 = function(clientOpts) {
     return new Protocol22(clientOpts);
@@ -1147,4 +1610,39 @@
     return new Protocol30(clientOpts);
   };
 
+  exports.version31 = function(clientOpts) {
+    return new Protocol31(clientOpts);
+  };
+
+  exports.version40 = function(clientOpts) {
+    return new Protocol40(clientOpts);
+  };
+
+  exports.version41 = function(clientOpts) {
+    return new Protocol41(clientOpts);
+  };
+
+  var VERSION_ORDER = ['4.1', '4.0', '3.1', '3.0', '2.9', '2.5', '2.2'];
+
+  exports.VERSION_ORDER = VERSION_ORDER;
+
+  /**
+   * Creates a protocol instance for the given version string.
+   * @param {string} version Protocol version (e.g. '3.1', '4.0').
+   * @param {Object} clientOpts Client configuration options.
+   * @returns {Object} Protocol instance.
+   */
+  exports.resolve = function(version, clientOpts) {
+    switch (version) {
+      case '4.1': return new Protocol41(clientOpts);
+      case '4.0': return new Protocol40(clientOpts);
+      case '3.1': return new Protocol31(clientOpts);
+      case '3.0': return new Protocol30(clientOpts);
+      case '2.9': return new Protocol29(clientOpts);
+      case '2.5': return new Protocol25(clientOpts);
+      case '2.2': return new Protocol22(clientOpts);
+      default: throw new Error(`Unknown protocol version: ${version}`);
+    }
+  };
+
 }.call(this));