infinispan 0.15.0 → 0.16.0

package/SECURITY.md

@@ -0,0 +1,27 @@
+# Security policy
+
+The Infinispan team and community take all security bugs very seriously.
+You can find our guidelines here regarding our policy and security disclosure.
+
+## Reporting security issues
+
+Please report any security issues you find in Infinispan to:
+
+    security at infinispan.org
+
+### Why follow this process
+
+Due to the sensitive nature of security bugs, the disclosure process is more constrained than a regular bug.
+We appreciate you following these industry accepted guidelines, which gives time for a proper fix and limit the time
+window of attack.
+
+## Supported Versions
+
+Use this section to tell people about which versions of your project are
+currently being supported with security updates.
+
+| Version  | Supported          |
+| -------- | ------------------ |
+| 0.14.0   | :white_check_mark: |
+| < 0.14.0 | :x:                |
+

package/lib/codec.js

@@ -36,6 +36,7 @@
   exports.decodeSignedInt = f.lift(doDecodeSignedInt, _.identity);
   exports.decodeVariableBytes = f.lift(doDecodeVariableBytes, _.identity);
   exports.decodeShort = f.lift(doDecodeShort, _.identity);
+  exports.decodeInt = f.lift(doDecodeInt, _.identity);
   exports.decodeProtobuf = f.lift(doDecodeProtobuf, _.identity);
   exports.decodeQuery = f.lift(doDecodeQuery,_.identity);
 
@@ -560,6 +561,17 @@
     return uncheckedReadShort(bytebuf)();
   }
 
+  function doDecodeInt(bytebuf) {
+    if (4 > bytebuf.buf.length - bytebuf.offset) {
+      logger.tracef('Can not fully read 4 bytes (buffer size is %d, buffer offset %d)',
+                    bytebuf.buf.length, bytebuf.offset);
+      return undefined;
+    }
+    var val = bytebuf.buf.readInt32BE(bytebuf.offset);
+    bytebuf.offset += 4;
+    return val;
+  }
+
   /**
    * Decode a Protobuf WrappedMessage from the buffer and unwrap it.
    * @param {Object} bytebuf - The byte buffer to read from.

package/lib/infinispan.js

@@ -18,6 +18,7 @@
   var io = require('./io');
   var listeners = require('./listeners');
   var nearCacheFactory = require('./near-cache');
+  var tx = require('./transaction');
 
   var Client = function(addrs, clientOpts) {
     var logger = u.logger('client');
@@ -39,6 +40,7 @@
     var p = protocolResolver(clientOpts['version']);
     var listen = listeners(p);
     var nc = clientOpts.nearCache ? nearCacheFactory(clientOpts.nearCache.maxEntries) : null;
+    var txCtx = null;
 
     var TINY = 16, SMALL = 32, MEDIUM = 64, BIG = 128;
 
@@ -327,6 +329,17 @@
        * @since 0.3
        */
       get: function(k) {
+        if (txCtx) {
+          var local = txCtx.getLocalValue(k);
+          if (local.found) return Promise.resolve(local.value);
+          var ctx = transport.context(SMALL);
+          logger.debugf('Invoke transactional get(msgId=%d,key=%s)', ctx.id, u.str(k));
+          var decoder = p.decodeWithMeta();
+          return futureKey(ctx, 0x1B, k, p.encodeKey(k), decoder).then(function(meta) {
+            txCtx.trackRead(k, meta);
+            return meta ? meta.value : undefined;
+          });
+        }
         if (nc) {
           var cached = nc.get(k);
           if (cached !== undefined) {
@@ -439,6 +452,8 @@
        * Lifespan for the stored entry.
        * @property {DurationUnit} maxIdle -
        * Max idle time for the stored entry.
+       * @property {Number} flags - Bitwise OR of Hot Rod flags
+       * (e.g. infinispan.flags.SKIP_CACHE_LOAD | infinispan.flags.SKIP_INDEXING).
        * @since 0.3
        */
       /**
@@ -455,6 +470,11 @@
        * @since 0.3
        */
       put: function(k, v, opts) {
+        if (txCtx) {
+          logger.debugf('Transactional put(key=%s)', u.str(k));
+          txCtx.trackPut(k, v);
+          return Promise.resolve(undefined);
+        }
         if (nc) nc.remove(k);
         var ctx = transport.context(MEDIUM);
         logger.debugl(function() { return ['Invoke put(msgId=%d,key=%s,value=%s,opts=%s)',
@@ -486,6 +506,11 @@
        * @since 0.3
        */
       remove: function(k, opts) {
+        if (txCtx) {
+          logger.debugf('Transactional remove(key=%s)', u.str(k));
+          txCtx.trackRemove(k);
+          return Promise.resolve(true);
+        }
         if (nc) nc.remove(k);
         var ctx = transport.context(SMALL);
         logger.debugl(function() {return ['Invoke remove(msgId=%d,key=%s,opts=%s)',
@@ -1073,6 +1098,122 @@
         logger.debugf('Invoke counterGetAndSet(msgId=%d,name=%s,value=%d)', ctx.id, name, value);
         return future(ctx, 0x7F, p.encodeCounterNameValue(name, value), p.decodeCounterValue);
       },
+      /**
+       * Get all values associated with a key in the multimap.
+       *
+       * @param {(String|Object)} k Key to retrieve.
+       * @returns {Promise.<Array>}
+       * A promise that will be completed with an array of values,
+       * or an empty array if the key does not exist.
+       * @memberof Client#
+       * @since 0.16
+       */
+      multimapGet: function(k) {
+        var ctx = transport.context(SMALL);
+        logger.debugf('Invoke multimapGet(msgId=%d,key=%s)', ctx.id, u.str(k));
+        return futureKey(ctx, 0x67, k, p.encodeMultimapKey(k), p.decodeMultimapCollection());
+      },
+      /**
+       * Add a value to the collection associated with a key in the multimap.
+       *
+       * @param {(String|Object)} k Key.
+       * @param {(String|Object)} v Value to add.
+       * @param {Object=} opts Optional store options (lifespan, maxIdle).
+       * @returns {Promise}
+       * A promise that will be completed when the value has been added.
+       * @memberof Client#
+       * @since 0.16
+       */
+      multimapPut: function(k, v, opts) {
+        var ctx = transport.context(MEDIUM);
+        logger.debugf('Invoke multimapPut(msgId=%d,key=%s,value=%s)', ctx.id, u.str(k), u.str(v));
+        return futureKey(ctx, 0x6B, k, p.encodeMultimapPut(k, v), p.complete(_.constant(undefined)), opts);
+      },
+      /**
+       * Remove all values associated with a key in the multimap.
+       *
+       * @param {(String|Object)} k Key to remove.
+       * @returns {Promise.<Boolean>}
+       * A promise that will be completed with true if the key existed.
+       * @memberof Client#
+       * @since 0.16
+       */
+      multimapRemoveKey: function(k) {
+        var ctx = transport.context(SMALL);
+        logger.debugf('Invoke multimapRemoveKey(msgId=%d,key=%s)', ctx.id, u.str(k));
+        return futureKey(ctx, 0x6D, k, p.encodeMultimapKey(k), p.decodeMultimapBoolean);
+      },
+      /**
+       * Remove a specific value from the collection associated with a key.
+       *
+       * @param {(String|Object)} k Key.
+       * @param {(String|Object)} v Value to remove.
+       * @returns {Promise.<Boolean>}
+       * A promise that will be completed with true if the entry existed.
+       * @memberof Client#
+       * @since 0.16
+       */
+      multimapRemoveEntry: function(k, v) {
+        var ctx = transport.context(SMALL);
+        logger.debugf('Invoke multimapRemoveEntry(msgId=%d,key=%s,value=%s)', ctx.id, u.str(k), u.str(v));
+        return futureKey(ctx, 0x6F, k, p.encodeMultimapKeyValue(k, v), p.decodeMultimapBoolean);
+      },
+      /**
+       * Get the total number of key-value pairs in the multimap.
+       *
+       * @returns {Promise.<Number>}
+       * A promise that will be completed with the total size.
+       * @memberof Client#
+       * @since 0.16
+       */
+      multimapSize: function() {
+        var ctx = transport.context(SMALL);
+        logger.debugf('Invoke multimapSize(msgId=%d)', ctx.id);
+        return future(ctx, 0x71, p.encodeMultimapSupportsDuplicates(), p.decodeMultimapSize);
+      },
+      /**
+       * Check whether a specific key-value pair exists in the multimap.
+       *
+       * @param {(String|Object)} k Key.
+       * @param {(String|Object)} v Value.
+       * @returns {Promise.<Boolean>}
+       * A promise that will be completed with true if the entry exists.
+       * @memberof Client#
+       * @since 0.16
+       */
+      multimapContainsEntry: function(k, v) {
+        var ctx = transport.context(SMALL);
+        logger.debugf('Invoke multimapContainsEntry(msgId=%d,key=%s,value=%s)', ctx.id, u.str(k), u.str(v));
+        return futureKey(ctx, 0x73, k, p.encodeMultimapKeyValue(k, v), p.decodeMultimapBoolean);
+      },
+      /**
+       * Check whether a key exists in the multimap.
+       *
+       * @param {(String|Object)} k Key to check.
+       * @returns {Promise.<Boolean>}
+       * A promise that will be completed with true if the key exists.
+       * @memberof Client#
+       * @since 0.16
+       */
+      multimapContainsKey: function(k) {
+        var ctx = transport.context(SMALL);
+        logger.debugf('Invoke multimapContainsKey(msgId=%d,key=%s)', ctx.id, u.str(k));
+        return futureKey(ctx, 0x75, k, p.encodeMultimapKey(k), p.decodeMultimapBoolean);
+      },
+      /**
+       * Check whether any key contains the given value in the multimap.
+       *
+       * @param {(String|Object)} v Value to check.
+       * @returns {Promise.<Boolean>}
+       * A promise that will be completed with true if any key contains the value.
+       * @memberof Client#
+       * @since 0.16
+       */
+      multimapContainsValue: function(v) {
+        var ctx = transport.context(SMALL);
+        logger.debugf('Invoke multimapContainsValue(msgId=%d,value=%s)', ctx.id, u.str(v));
+        return future(ctx, 0x77, p.encodeMultimapValue(v), p.decodeMultimapBoolean);
+      },
       /**
        * Get server topology related information.
        *
@@ -1261,6 +1402,73 @@
           logger.debugf('Invoke admin.removeSchema(msgId=%d,name=%s)', ctx.id, name);
           return future(ctx, 0x2B, p.encodeNameParams('@@schemas@delete', {name: name}), p.decodeValue());
         }
+      },
+      /**
+       * Get the transaction manager for this client.
+       * Transactions buffer put/remove operations locally and send them
+       * to the server atomically on commit via PREPARE_TX_2.
+       * During an active transaction, get() reads local writes first,
+       * falling back to getWithMetadata to capture entry versions for
+       * conflict detection.
+       *
+       * @returns {Object} Transaction manager with begin(), commit(), and rollback() methods.
+       * @memberof Client#
+       * @since 0.16
+       */
+      getTransactionManager: function() {
+        return {
+          begin: function() {
+            if (txCtx) throw new Error('Transaction already active');
+            txCtx = new tx.TransactionContext();
+            logger.debugf('Transaction started (xid=%s)',
+              txCtx.xid.globalTxId.toString('hex'));
+            return Promise.resolve();
+          },
+          commit: function() {
+            if (!txCtx) throw new Error('No active transaction');
+            var xid = txCtx.xid;
+            var mods = txCtx.getModifications();
+            if (mods.length === 0) {
+              txCtx = null;
+              return Promise.resolve();
+            }
+            var ctx = transport.context(BIG);
+            logger.debugf('Invoke prepareTx(msgId=%d, mods=%d)', ctx.id, mods.length);
+            var decoder = p.decodeXaResponse();
+            return future(ctx, 0x7D, p.encodePrepare(xid, mods, true, 60000), decoder)
+              .then(function(xaCode) {
+                txCtx = null;
+                if (xaCode !== tx.XA_OK && xaCode !== tx.XA_RDONLY) {
+                  throw new Error(`Transaction prepare failed: XA code ${xaCode}`);
+                }
+              })
+              .catch(function(err) {
+                txCtx = null;
+                throw err;
+              });
+          },
+          rollback: function() {
+            if (!txCtx) throw new Error('No active transaction');
+            var xid = txCtx.xid;
+            var mods = txCtx.getModifications();
+            if (mods.length === 0) {
+              txCtx = null;
+              return Promise.resolve();
+            }
+            var ctx = transport.context(SMALL);
+            logger.debugf('Invoke rollbackTx(msgId=%d)', ctx.id);
+            var decoder = p.decodeXaResponse();
+            return future(ctx, 0x3F, p.encodeXidOnly(xid), decoder)
+              .then(function() { txCtx = null; })
+              .catch(function(err) {
+                txCtx = null;
+                throw err;
+              });
+          },
+          isActive: function() {
+            return txCtx !== null;
+          }
+        };
       }
     };
   };
@@ -1390,6 +1598,8 @@
    * @returns {Promise<ReturnType<Client>>} A promise that resolves to a connected client.
    * @since 0.3
    */
+  exports.flags = protocols.FLAGS;
+
   exports.client = function client(args, options) {
     var addrs, uriOpts;
     if (uri.isHotrodURI(args)) {

package/lib/protocols.js

@@ -23,6 +23,15 @@
   var INFINITE_LIFESPAN = 0x01, INFINITE_MAXIDLE = 0x02; // Duration flag masks
   var MAGIC = 0xA0;
 
+  var FLAGS = {
+    FORCE_RETURN_VALUE: 0x0001,
+    DEFAULT_LIFESPAN: 0x0002,
+    DEFAULT_MAXIDLE: 0x0004,
+    SKIP_CACHE_LOAD: 0x0008,
+    SKIP_INDEXING: 0x0010,
+    SKIP_LISTENER_NOTIFICATION: 0x0020
+  };
+
   /**
    * Creates decode actions for a key-value pair.
    * @param {Object} decoderKey Key decoder descriptor.
@@ -129,8 +138,10 @@
     };
 
     return {
-      buildFlags: function (opts) { // TODO: Move out to a Mixin (similar to expiry)
-        return hasOptPrev(opts) ? 0x01 : 0;
+      buildFlags: function (opts) {
+        var result = hasOptPrev(opts) ? FLAGS.FORCE_RETURN_VALUE : 0;
+        if (hasOpt(opts, 'flags')) result |= opts.flags;
+        return result;
       },
       /**
        * Returns the protocol version as a human-readable string (e.g. '3.1').
@@ -577,8 +588,8 @@
         return hasPrevious(header.status);
       },
       isEvent: function(header) {
-        //return ((op(header) >> 4) & 0x06) == 0x06;
-        return ((header.opCode >> 4) & 0x06) == 0x06;
+        var op = header.opCode;
+        return op >= 0x60 && op <= 0x64;
       },
       isError: function(header) {
         return header.opCode == 0x50;
@@ -1323,6 +1334,81 @@
     };
   }());
 
+  var MultimapMixin = (function() {
+    var SUPPORTS_DUPLICATES = codec.encodeUByte(0x00);
+
+    return {
+      encodeMultimapKey: function(k) {
+        var outer = this;
+        return function() {
+          return [outer.encodeMediaKey(k), SUPPORTS_DUPLICATES];
+        };
+      },
+      encodeMultimapPut: function(k, v) {
+        var outer = this;
+        return function(opts) {
+          return f.cat(
+            [outer.encodeMediaKey(k)],
+            outer.encodeExpiry(opts),
+            [outer.encodeMediaValue(v), SUPPORTS_DUPLICATES]
+          );
+        };
+      },
+      encodeMultimapKeyValue: function(k, v) {
+        var outer = this;
+        return function() {
+          return f.cat(
+            [outer.encodeMediaKey(k)],
+            [codec.encodeUByte(0x77)],
+            [outer.encodeMediaValue(v), SUPPORTS_DUPLICATES]
+          );
+        };
+      },
+      encodeMultimapValue: function(v) {
+        var outer = this;
+        return function() {
+          return [codec.encodeUByte(0x77), outer.encodeMediaValue(v), SUPPORTS_DUPLICATES];
+        };
+      },
+      encodeMultimapSupportsDuplicates: function() {
+        return function() {
+          return [SUPPORTS_DUPLICATES];
+        };
+      },
+      decodeMultimapCollection: function() {
+        var decoderValue = decoderMedia(this.valueMediaType);
+        var decodeSingleValue = decodeSingle(decoderValue);
+        return function(header, bytebuf) {
+          if (header.status !== 0x00 && header.status !== 0x03)
+            return {result: [], continue: true};
+          var count = DECODE_VINT(bytebuf);
+          if (!f.existy(count))
+            return {continue: false};
+          var values = [];
+          for (var i = 0; i < count; i++) {
+            var v = decodeSingleValue(bytebuf);
+            if (!f.existy(v))
+              return {continue: false};
+            values.push(v);
+          }
+          return {result: values, continue: true};
+        };
+      },
+      decodeMultimapBoolean: function(header, bytebuf) {
+        var b = DECODE_UBYTE(bytebuf);
+        if (!f.existy(b))
+          return {continue: false};
+        return {result: b !== 0, continue: true};
+      },
+      decodeMultimapSize: function(header, bytebuf) {
+        var size = f.actions([codec.decodeVLong()], codec.lastDecoded)(bytebuf);
+        if (!f.existy(size) && size !== 0)
+          return {continue: false};
+        return {result: size, continue: true};
+      }
+    };
+  }());
+
   /**
    * Protocol 4.0+ requires an 'otherParams' map after media types in the header.
    * This mixin overrides stepsHeader to append the count (0 = no params).
@@ -1428,6 +1514,54 @@
   }());
   
 
+  var DECODE_INT = f.actions([codec.decodeInt()], codec.lastDecoded);
+
+  var TransactionMixin = {
+    encodeXid: function(xid) {
+      return [
+        codec.encodeSignedInt(xid.formatId),
+        codec.encodeBytesWithLength(xid.globalTxId),
+        codec.encodeBytesWithLength(xid.branchQualifier)
+      ];
+    },
+    encodePrepare: function(xid, modifications, onePhaseCommit, timeout) {
+      var outer = this;
+      return function() {
+        var steps = outer.encodeXid(xid);
+        steps.push(codec.encodeUByte(onePhaseCommit ? 1 : 0));
+        steps.push(codec.encodeUByte(0)); // not recoverable
+        steps.push(codec.encodeLong(timeout));
+        steps.push(codec.encodeVInt(modifications.length));
+        for (var i = 0; i < modifications.length; i++) {
+          var mod = modifications[i];
+          steps.push(outer.encodeMediaKey(mod.key));
+          steps.push(codec.encodeUByte(mod.controlByte));
+          if (!(mod.controlByte & 0x1) && !(mod.controlByte & 0x2)) {
+            steps.push(codec.encodeBytes(mod.versionRead));
+          }
+          if (!(mod.controlByte & 0x4)) {
+            steps.push(codec.encodeUByte(0x77));
+            steps.push(outer.encodeMediaValue(mod.value));
+          }
+        }
+        return steps;
+      };
+    },
+    encodeXidOnly: function(xid) {
+      var outer = this;
+      return function() {
+        return outer.encodeXid(xid);
+      };
+    },
+    decodeXaResponse: function() {
+      return function(header, bytebuf) {
+        var code = DECODE_INT(bytebuf);
+        if (!f.existy(code)) return {continue: false};
+        return {result: code, continue: true};
+      };
+    }
+  };
+
   /**
    * Constructs a Hot Rod protocol instance for the given version.
    * @param {number} v Protocol version number.
@@ -1516,13 +1650,7 @@
       , Ping29Mixin
       , 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
+      , TransactionMixin
   );
 
   _.extend(Protocol30.prototype
@@ -1538,6 +1666,7 @@
     , Ping30Mixin
     , ProtostreamType
     , ProtobufRoot
+    , TransactionMixin
   );
 
   _.extend(Protocol31.prototype
@@ -1552,9 +1681,10 @@
     , SASLMixin
     , Ping30Mixin
     , CounterMixin
+    , MultimapMixin
     , ProtostreamType
     , ProtobufRoot
-    // TODO 3.1 new ops: bloom filter near-cache
+    , TransactionMixin
   );
 
   _.extend(Protocol40.prototype
@@ -1571,8 +1701,10 @@
     , SASLMixin
     , Ping30Mixin
     , CounterMixin
+    , MultimapMixin
     , ProtostreamType
     , ProtobufRoot
+    , TransactionMixin
   );
 
   _.extend(Protocol41.prototype
@@ -1589,9 +1721,10 @@
     , SASLMixin
     , Ping30Mixin
     , CounterMixin
+    , MultimapMixin
     , ProtostreamType
     , ProtobufRoot
-    // TODO 4.1 new ops: chunked streaming (GetStreamStart/Next/End, PutStreamStart/Next/End)
+    , TransactionMixin
   );
 
   exports.version22 = function(clientOpts) {
@@ -1626,6 +1759,8 @@
 
   exports.VERSION_ORDER = VERSION_ORDER;
 
+  exports.FLAGS = FLAGS;
+
   /**
    * Creates a protocol instance for the given version string.
    * @param {string} version Protocol version (e.g. '3.1', '4.0').

package/lib/transaction.js

@@ -0,0 +1,123 @@
+'use strict';
+
+(function() {
+
+  var crypto = require('crypto');
+
+  var FORMAT_ID = 0x48525458;
+  var NOT_READ = 0x1, NON_EXISTING = 0x2, REMOVE_OP = 0x4;
+  var XA_OK = 0, XA_RDONLY = 3;
+
+  function generateXid() {
+    return {
+      formatId: FORMAT_ID,
+      globalTxId: crypto.randomBytes(16),
+      branchQualifier: crypto.randomBytes(16)
+    };
+  }
+
+  function TransactionContext() {
+    this.xid = generateXid();
+    // key (string) → { value, removed (bool), versionRead (Buffer|null), wasRead (bool), existed (bool) }
+    this.entries = new Map();
+    this.active = true;
+  }
+
+  TransactionContext.prototype.trackPut = function(key, value) {
+    var entry = this.entries.get(key);
+    if (entry) {
+      entry.value = value;
+      entry.removed = false;
+    } else {
+      this.entries.set(key, {
+        value: value,
+        removed: false,
+        versionRead: null,
+        wasRead: false,
+        existed: false
+      });
+    }
+  };
+
+  TransactionContext.prototype.trackRemove = function(key) {
+    var entry = this.entries.get(key);
+    if (entry) {
+      entry.removed = true;
+      entry.value = undefined;
+    } else {
+      this.entries.set(key, {
+        value: undefined,
+        removed: true,
+        versionRead: null,
+        wasRead: false,
+        existed: false
+      });
+    }
+  };
+
+  TransactionContext.prototype.trackRead = function(key, meta) {
+    var entry = this.entries.get(key);
+    var version = meta ? meta.version : null;
+    var existed = meta !== undefined;
+    if (entry) {
+      if (!entry.wasRead) {
+        entry.wasRead = true;
+        entry.versionRead = version;
+        entry.existed = existed;
+      }
+    } else {
+      this.entries.set(key, {
+        value: meta ? meta.value : undefined,
+        removed: false,
+        versionRead: version,
+        wasRead: true,
+        existed: existed
+      });
+    }
+  };
+
+  TransactionContext.prototype.getLocalValue = function(key) {
+    var entry = this.entries.get(key);
+    if (!entry) return { found: false };
+    if (entry.removed) return { found: true, value: undefined };
+    if (entry.value !== undefined) return { found: true, value: entry.value };
+    return { found: false };
+  };
+
+  TransactionContext.prototype.computeControlByte = function(entry) {
+    var control = 0;
+    if (!entry.wasRead) {
+      control |= NOT_READ;
+    } else if (!entry.existed) {
+      control |= NON_EXISTING;
+    }
+    if (entry.removed) {
+      control |= REMOVE_OP;
+    }
+    return control;
+  };
+
+  TransactionContext.prototype.getModifications = function() {
+    var mods = [];
+    this.entries.forEach(function(entry, key) {
+      var control = this.computeControlByte(entry);
+      mods.push({
+        key: key,
+        controlByte: control,
+        versionRead: entry.versionRead,
+        value: entry.value
+      });
+    }.bind(this));
+    return mods;
+  };
+
+  exports.TransactionContext = TransactionContext;
+  exports.generateXid = generateXid;
+  exports.FORMAT_ID = FORMAT_ID;
+  exports.NOT_READ = NOT_READ;
+  exports.NON_EXISTING = NON_EXISTING;
+  exports.REMOVE_OP = REMOVE_OP;
+  exports.XA_OK = XA_OK;
+  exports.XA_RDONLY = XA_RDONLY;
+
+}.call(this));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "infinispan",
-  "version": "0.15.0",
+  "version": "0.16.0",
   "description": "Infinispan Javascript client",
   "main": "index",
   "typings": "./types",
@@ -9,8 +9,7 @@
   },
   "scripts": {
     "lint": "eslint --ignore-path .gitignore lib spec index.js",
-    "test": "jasmine",
-    "test:docker": "node scripts/docker-test.js",
+    "test": "node scripts/docker-test.js",
     "docker:up": "docker compose -p ispn-test up -d --wait && docker compose -p ispn-test --profile failover create server-failover-one server-failover-two server-failover-three",
     "docker:down": "docker compose -p ispn-test --profile failover down --remove-orphans",
     "ssl:generate": "node scripts/make-ssl.js",