aerospike 5.2.0 → 5.2.1

package/binding.gyp

@@ -52,7 +52,7 @@
               'action': [
                 'pwsh', 'scripts/build-c-client.ps1',
                     '-Configuration', "$(ConfigurationName)",
-                    '-NodeLibFile', "<(node_root_dir)/<(build_arch)/node.lib"
+                    '-NodeLibFile', "<(node_root_dir)/<(target_arch)/node.lib"
               ]
             }
           ]

package/lib/bitwise.js

@@ -42,26 +42,28 @@ const as = require('bindings')('aerospike.node')
 const opcodes = as.bitOperations
 
 /**
- * @class aerospike/bitwise~BitwiseOperation
+ * @class module:aerospike/bitwise~BitwiseOperation
  *
  * @classdesc Use the methods in the {@link module:aerospike/bitwise|bitwise}
  * module to create bitwise operations for use with the {@link Client#operate}
  * command.
  */
 class BitwiseOperation extends Operation {
-  /**
-   * @summary Applies a {@link BitwisePolicy} to the operation.
-   *
-   * @param {BitwisePolicy} policy - Policy to apply to the operation.
-   */
-  withPolicy (policy) {
-    this.policy = policy
-    return this
-  }
+
+}
+
+/**
+ * @summary Applies a {@link BitwisePolicy} to the operation.
+ *
+ * @param {BitwisePolicy} policy - Policy to apply to the operation.
+ */
+BitwiseOperation.prototype.withPolicy = function (policy) {
+  this.policy = policy
+  return this
 }
 
 /**
- * @class aerospike/bitwise~OverflowableBitwiseOp
+ * @class module:aerospike/bitwise~OverflowableBitwiseOp
  *
  * @classdesc Bitwise operation variant that can overflow/underflow.
  *
@@ -73,17 +75,17 @@ class OverflowableBitwiseOp extends BitwiseOperation {
     super(op, bin, props)
     this.overflowAction = as.bitwise.overflow.FAIL
   }
+}
 
-  /**
-   * @summary Sets the action to take when the operation overflows/underflows.
-   *
-   * @param {number} action - {@link module:aerospike/bitwise.overflow|overflow
-   * action} to apply to the operation.
-   */
-  onOverflow (action) {
-    this.overflowAction = action
-    return this
-  }
+/**
+ * @summary Sets the action to take when the operation overflows/underflows.
+ *
+ * @param {number} action - {@link module:aerospike/bitwise.overflow|overflow
+ * action} to apply to the operation.
+ */
+OverflowableBitwiseOp.prototype.onOverflow = function (action) {
+  this.overflowAction = action
+  return this
 }
 
 /**

package/lib/cdt_context.js

@@ -66,6 +66,33 @@ class CdtContext {
     return this.add(LIST_INDEX, index)
   }
 
+  /**
+   * @summary Lookup list by base list's index offset.
+   *
+   * @description If the list at index offset is not found,
+   * create it with the given sort order at that index offset.
+   * If pad is true and the index offset is greater than the
+   * bounds of the base list, nil entries will be inserted before the newly
+   * created list.
+   *
+   * @param {number} index - List index
+   * @param {number} order - Sort order used if a list is created
+   * @param {boolean} pad - Pads list entries between index and the
+   * final list entry with zeros.
+   * @return {CdtContext} Updated CDT context, so calls can be chained.
+   */
+  addListIndexCreate (index, order, pad) {
+    if (order) {
+      return this.add(LIST_INDEX | 0xc0, index)
+    } else {
+      if (pad) {
+        return this.add(LIST_INDEX | 0x80, index)
+      } else {
+        return this.add(LIST_INDEX | 0x40, index)
+      }
+    }
+  }
+
   /**
    * @summary Lookup list by rank.
    *
@@ -137,6 +164,24 @@ class CdtContext {
     return this.add(MAP_KEY, key)
   }
 
+  /**
+   * @summary Lookup map by base map's key. If the map at key is not found,
+   * create it with the given sort order at that key.
+   *
+   * @param {any} key - Map key
+   * @param {number} order - Sort order used if a map is created
+   * @return {CdtContext} Updated CDT context, so calls can be chained.
+   */
+  addMapKeyCreate (key, order) {
+    if (!order) {
+      return this.add(MAP_KEY | 0x40, key)
+    } else if (order === 1) {
+      return this.add(MAP_KEY | 0x80, key)
+    } else {
+      return this.add(MAP_KEY | 0xc0, key)
+    }
+  }
+
   /**
    * @summary Lookup map by value.
    *

package/lib/exp.js

@@ -623,7 +623,7 @@ exports.mul = _VAExp(exp.ops.MUL)
 exports.div = _VAExp(exp.ops.DIV)
 
 const _paramsExp = (op) => (...params) => [
-  { op: op, count: params.length + 1 },
+  { op, count: params.length + 1 },
   ...params
 ]
 

package/lib/exp_operations.js

@@ -71,7 +71,7 @@ const ops = as.expOperations
 
 /**
  * @protected
- * @class aerospike/exp_operations~ExpOperation
+ * @class module:aerospike/exp_operations~ExpOperation
  *
  * @classdesc class for all expression operations executed with the {@link
  * Client#operate} command.

package/lib/filter.js

@@ -46,7 +46,7 @@ const GeoJSON = require('./geojson')
  */
 
 /**
- * @class aerospike/filter~SindexFilterPredicate
+ * @class module:aerospike/filter~SindexFilterPredicate
  * @classdesc SI filter predicate to limit the scope of a {@link Query}.
  *
  * Filter predicates must be instantiated using the methods in the {@link

package/lib/hll.js

@@ -108,22 +108,24 @@ const GET_SIMILARITY_COMMAND = 54
 const DESCRIBE_COMMAND = 55
 
 /**
- * @class aerospike/hll~HLLOperation
+ * @class module:aerospike/hll~HLLOperation
  *
  * @classdesc Use the methods in the {@link module:aerospike/hll|hll}
  * module to create HLL operations for use with the {@link Client#operate}
  * command.
  */
 class HLLOperation extends Operation {
-  /**
-   * @summary Applies a {@link HLLPolicy} to the operation.
-   *
-   * @param {HLLPolicy} policy - Policy to apply to the operation.
-   */
-  withPolicy (policy) {
-    this.policy = policy
-    return this
-  }
+
+}
+
+/**
+ * @summary Applies a {@link HLLPolicy} to the operation.
+ *
+ * @param {HLLPolicy} policy - Policy to apply to the operation.
+ */
+HLLOperation.prototype.withPolicy = function (policy) {
+  this.policy = policy
+  return this
 }
 
 /**

package/lib/lists.js

@@ -61,164 +61,166 @@ const AerospikeError = require('./error')
 const Operation = require('./operations').Operation
 
 /**
- * @class aerospike/lists~ListOperation
+ * @class module:aerospike/lists~ListOperation
  *
  * @classdesc Use the methods in the {@link module:aerospike/lists|lists}
  * module to create list operations for use with the {@link Client#operate}
  * command.
  */
 class ListOperation extends Operation {
-  /**
-   * @summary Set the return type for certain list operations.
-   * @description The return type only affects <code>getBy\*</code> and
-   * <code>removeBy\*</code> list operations.
-   *
-   * @param {number} returnType - The {@link
-   * module:aerospike/lists.returnType|return type} indicating what data of the
-   * selected items to return.
-   *
-   * @example <caption>Fetch the first three list elements and return the values</caption>
-   *
-   * const Aerospike = require('aerospike')
-   * const lists = Aerospike.lists
-   * const key = new Aerospike.Key('test', 'demo', 'listsTest')
-   * // INSERT HOSTNAME AND PORT NUMBER OF AEROSPIKE SERVER NODE HERE!
-   * var config = {
-   *   hosts: '192.168.33.10:3000',
-   *   // Timeouts disabled, latency dependent on server location. Configure as needed.
-   *   policies: {
-   *     write : new Aerospike.WritePolicy({socketTimeout : 0, totalTimeout : 0}),
-   *     operate : new Aerospike.OperatePolicy({socketTimeout : 0, totalTimeout : 0})
-   *   }
-   * }
-   * Aerospike.connect(config).then(async client => {
-   *   await client.put(key, { list: [32, 5, 85, 16, 22] })
-   *   const ops = [
-   *     lists.getByValueRange('list', 10, 30)
-   *       .andReturn(lists.returnType.VALUE)
-   *   ]
-   *   const result = await client.operate(key, ops)
-   *   console.log('Result:', result.bins.list) // => Result: [ 16, 22 ]
-   *   client.close()
-   * })
-   */
-  andReturn (returnType) {
-    this.returnType = returnType
-    return this
-  }
 
-  /**
-   * @summary By setting the context, the list operation will be executed on a
-   * nested list, instead of the bin value itself.
-   *
-   * @param { CdtContext | function } context - Either a Context object, or a
-   * function which accepts a Context object.
-   * @returns { ListOperation } The list operation itself.
-   *
-   * @since v3.12.0
-   *
-   * @example <caption>Fetch the 1st element of the 2nd nested list</caption>
-   *
-   * const Aerospike = require('aerospike')
-   * const lists = Aerospike.lists
-   * const key = new Aerospike.Key('test', 'demo', 'listsTest')
-   * // INSERT HOSTNAME AND PORT NUMBER OF AEROSPIKE SERVER NODE HERE!
-   * var config = {
-   *   hosts: '192.168.33.10:3000',
-   *   // Timeouts disabled, latency dependent on server location. Configure as needed.
-   *   policies: {
-   *     write : new Aerospike.WritePolicy({socketTimeout : 0, totalTimeout : 0}),
-   *     operate : new Aerospike.OperatePolicy({socketTimeout : 0, totalTimeout : 0})
-   *   }
-   * }
-   * Aerospike.connect(config).then(async (client) => {
-   *   await client.put(key, { list: [[32, 5, 85], [16, 22]] })
-   *   const ops = [
-   *     lists.get('list', 0)
-   *       .withContext((ctx) => ctx.addListIndex(1))
-   *   ]
-   *   const result = await client.operate(key, ops)
-   *   console.log('Result:', result.bins.list) // => Result: 16
-   *   client.close()
-   * })
-   *
-   * @example <caption>Fetch the last element of the nested list stored under the 'nested' map key</caption>
-   *
-   * const Aerospike = require('aerospike')
-   * const lists = Aerospike.lists
-   * const Context = Aerospike.cdt.Context
-   * const key = new Aerospike.Key('test', 'demo', 'listsTest')
-   * // INSERT HOSTNAME AND PORT NUMBER OF AEROSPIKE SERVER NODE HERE!
-   * var config = {
-   *   hosts: '192.168.33.10:3000',
-   *   // Timeouts disabled, latency dependent on server location. Configure as needed.
-   *   policies: {
-   *     write : new Aerospike.WritePolicy({socketTimeout : 0, totalTimeout : 0}),
-   *     operate : new Aerospike.OperatePolicy({socketTimeout : 0, totalTimeout : 0})
-   *   }
-   * }
-   * Aerospike.connect(config).then(async (client) => {
-   *   await client.put(key, { map: { nested: [32, 5, 85, 16, 22] } })
-   *   const context = new Context().addMapKey('nested')
-   *   const ops = [
-   *     lists.get('map', -1)
-   *       .withContext(context)
-   *   ]
-   *   const result = await client.operate(key, ops)
-   *   console.log('Result:', result.bins.map) // => Result: 22
-   *   client.close()
-   * })
-   */
-  withContext (contextOrFunction) {
-    if (contextOrFunction instanceof Context) {
-      this.context = contextOrFunction
-    } else if (typeof contextOrFunction === 'function') {
-      this.context = new Context()
-      contextOrFunction(this.context)
-    } else {
-      throw new AerospikeError('Context param must be a CDT Context or a function that accepts a context')
-    }
-    return this
-  }
+}
 
-  /**
-   * @summary Inverts the selection of items for certain list operations.
-   * @description For <code>getBy\*</code> and <code>removeBy\*</code> list
-   * operations, calling the <code>invertSelect</code> method on the
-   * <code>ListOperation</code> has the effect of inverting the selection of
-   * list elements that the operation affects.
-   *
-   * @throws {AerospikeError} if the operation is not invertible.
-   *
-   * @example <caption>Remove all tags except for yellow from the record</caption>
-   *
-   * const Aerospike = require('aerospike')
-   * const lists = Aerospike.lists
-   * const key = new Aerospike.Key('test', 'demo', 'listsTest')
-   * // INSERT HOSTNAME AND PORT NUMBER OF AEROSPIKE SERVER NODE HERE!
-   * var config = {
-   *   hosts: '192.168.33.10:3000',
-   *   // Timeouts disabled, latency dependent on server location. Configure as needed.
-   *   policies: {
-   *     write : new Aerospike.WritePolicy({socketTimeout : 0, totalTimeout : 0}),
-   *     operate : new Aerospike.OperatePolicy({socketTimeout : 0, totalTimeout : 0})
-   *   }
-   * }
-   * Aerospike.connect(config).then(async client => {
-   *   await client.put(key, { tags: ['blue', 'yellow', 'pink'] })
-   *   const ops = [
-   *     lists.removeByValue('tags', 'yellow')
-   *       .invertSelection()
-   *   ]
-   *   await client.operate(key, ops)
-   *   const record = await client.get(key)
-   *   console.log('Result:', record.bins.tags) // => Result: [ 'yellow' ]
-   *   client.close()
-   * })
-   */
-  invertSelection () {
-    throw new AerospikeError(`List operation cannot be inverted [op ${this.op}]`)
+/**
+ * @summary Inverts the selection of items for certain list operations.
+ * @description For <code>getBy\*</code> and <code>removeBy\*</code> list
+ * operations, calling the <code>invertSelect</code> method on the
+ * <code>ListOperation</code> has the effect of inverting the selection of
+ * list elements that the operation affects.
+ *
+ * @throws {AerospikeError} if the operation is not invertible.
+ *
+ * @example <caption>Remove all tags except for yellow from the record</caption>
+ *
+ * const Aerospike = require('aerospike')
+ * const lists = Aerospike.lists
+ * const key = new Aerospike.Key('test', 'demo', 'listsTest')
+ * // INSERT HOSTNAME AND PORT NUMBER OF AEROSPIKE SERVER NODE HERE!
+ * var config = {
+ *   hosts: '192.168.33.10:3000',
+ *   // Timeouts disabled, latency dependent on server location. Configure as needed.
+ *   policies: {
+ *     write : new Aerospike.WritePolicy({socketTimeout : 0, totalTimeout : 0}),
+ *     operate : new Aerospike.OperatePolicy({socketTimeout : 0, totalTimeout : 0})
+ *   }
+ * }
+ * Aerospike.connect(config).then(async client => {
+ *   await client.put(key, { tags: ['blue', 'yellow', 'pink'] })
+ *   const ops = [
+ *     lists.removeByValue('tags', 'yellow')
+ *       .invertSelection()
+ *   ]
+ *   await client.operate(key, ops)
+ *   const record = await client.get(key)
+ *   console.log('Result:', record.bins.tags) // => Result: [ 'yellow' ]
+ *   client.close()
+ * })
+ */
+ListOperation.prototype.invertSelection = function () {
+  throw new AerospikeError(`List operation cannot be inverted [op ${this.op}]`)
+}
+
+/**
+ * @summary By setting the context, the list operation will be executed on a
+ * nested list, instead of the bin value itself.
+ *
+ * @param { CdtContext | function } context - Either a Context object, or a
+ * function which accepts a Context object.
+ * @returns { ListOperation } The list operation itself.
+ *
+ * @since v3.12.0
+ *
+ * @example <caption>Fetch the 1st element of the 2nd nested list</caption>
+ *
+ * const Aerospike = require('aerospike')
+ * const lists = Aerospike.lists
+ * const key = new Aerospike.Key('test', 'demo', 'listsTest')
+ * // INSERT HOSTNAME AND PORT NUMBER OF AEROSPIKE SERVER NODE HERE!
+ * var config = {
+ *   hosts: '192.168.33.10:3000',
+ *   // Timeouts disabled, latency dependent on server location. Configure as needed.
+ *   policies: {
+ *     write : new Aerospike.WritePolicy({socketTimeout : 0, totalTimeout : 0}),
+ *     operate : new Aerospike.OperatePolicy({socketTimeout : 0, totalTimeout : 0})
+ *   }
+ * }
+ * Aerospike.connect(config).then(async (client) => {
+ *   await client.put(key, { list: [[32, 5, 85], [16, 22]] })
+ *   const ops = [
+ *     lists.get('list', 0)
+ *       .withContext((ctx) => ctx.addListIndex(1))
+ *   ]
+ *   const result = await client.operate(key, ops)
+ *   console.log('Result:', result.bins.list) // => Result: 16
+ *   client.close()
+ * })
+ *
+ * @example <caption>Fetch the last element of the nested list stored under the 'nested' map key</caption>
+ *
+ * const Aerospike = require('aerospike')
+ * const lists = Aerospike.lists
+ * const Context = Aerospike.cdt.Context
+ * const key = new Aerospike.Key('test', 'demo', 'listsTest')
+ * // INSERT HOSTNAME AND PORT NUMBER OF AEROSPIKE SERVER NODE HERE!
+ * var config = {
+ *   hosts: '192.168.33.10:3000',
+ *   // Timeouts disabled, latency dependent on server location. Configure as needed.
+ *   policies: {
+ *     write : new Aerospike.WritePolicy({socketTimeout : 0, totalTimeout : 0}),
+ *     operate : new Aerospike.OperatePolicy({socketTimeout : 0, totalTimeout : 0})
+ *   }
+ * }
+ * Aerospike.connect(config).then(async (client) => {
+ *   await client.put(key, { map: { nested: [32, 5, 85, 16, 22] } })
+ *   const context = new Context().addMapKey('nested')
+ *   const ops = [
+ *     lists.get('map', -1)
+ *       .withContext(context)
+ *   ]
+ *   const result = await client.operate(key, ops)
+ *   console.log('Result:', result.bins.map) // => Result: 22
+ *   client.close()
+ * })
+ */
+ListOperation.prototype.withContext = function (contextOrFunction) {
+  if (contextOrFunction instanceof Context) {
+    this.context = contextOrFunction
+  } else if (typeof contextOrFunction === 'function') {
+    this.context = new Context()
+    contextOrFunction(this.context)
+  } else {
+    throw new AerospikeError('Context param must be a CDT Context or a function that accepts a context')
   }
+  return this
+}
+
+/**
+ * @summary Set the return type for certain list operations.
+ * @description The return type only affects <code>getBy\*</code> and
+ * <code>removeBy\*</code> list operations.
+ *
+ * @param {number} returnType - The {@link
+ * module:aerospike/lists.returnType|return type} indicating what data of the
+ * selected items to return.
+ *
+ * @example <caption>Fetch the first three list elements and return the values</caption>
+ *
+ * const Aerospike = require('aerospike')
+ * const lists = Aerospike.lists
+ * const key = new Aerospike.Key('test', 'demo', 'listsTest')
+ * // INSERT HOSTNAME AND PORT NUMBER OF AEROSPIKE SERVER NODE HERE!
+ * var config = {
+ *   hosts: '192.168.33.10:3000',
+ *   // Timeouts disabled, latency dependent on server location. Configure as needed.
+ *   policies: {
+ *     write : new Aerospike.WritePolicy({socketTimeout : 0, totalTimeout : 0}),
+ *     operate : new Aerospike.OperatePolicy({socketTimeout : 0, totalTimeout : 0})
+ *   }
+ * }
+ * Aerospike.connect(config).then(async client => {
+ *   await client.put(key, { list: [32, 5, 85, 16, 22] })
+ *   const ops = [
+ *     lists.getByValueRange('list', 10, 30)
+ *       .andReturn(lists.returnType.VALUE)
+ *   ]
+ *   const result = await client.operate(key, ops)
+ *   console.log('Result:', result.bins.list) // => Result: [ 16, 22 ]
+ *   client.close()
+ * })
+ */
+ListOperation.prototype.andReturn = function (returnType) {
+  this.returnType = returnType
+  return this
 }
 
 /**