@valkey/valkey-glide-darwin-arm64 1.2.0-rc7 → 1.2.0-rc8

package/rust-client/node_modules/pause-stream/test/pause-end.js

@@ -0,0 +1,33 @@
+
+var pause = require('..')
+var assert = require('assert')
+
+var ps = pause()
+var read = [], ended = false
+
+ps.on('data', function (i) {
+  read.push(i)
+})
+
+ps.on('end', function () {
+  ended = true
+})
+
+assert.deepEqual(read, [])
+
+ps.write(0)
+ps.write(1)
+ps.write(2)
+
+assert.deepEqual(read, [0, 1, 2])
+
+ps.pause()
+
+assert.deepEqual(read, [0, 1, 2])
+
+ps.end()
+assert.equal(ended, false)
+ps.resume()
+assert.equal(ended, true)
+
+

package/rust-client/node_modules/save/.eslintignore

@@ -0,0 +1 @@
+node_modules

package/rust-client/node_modules/save/.eslintrc

@@ -0,0 +1,12 @@
+{
+    "extends": ["standard", "plugin:prettier/recommended", "prettier/standard"],
+    "env": {
+      "es6": true,
+      "mocha": true,
+      "node": true,
+      "browser": true
+    },
+    "parserOptions": {
+      "ecmaVersion": 2018
+    }
+  }

package/rust-client/node_modules/save/.prettierignore

@@ -0,0 +1,10 @@
+# Dependencies
+/node_modules
+
+# Misc 
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# Editor
+.vscode

package/rust-client/node_modules/save/.prettierrc

@@ -0,0 +1,5 @@
+{
+    "semi": false,
+    "singleQuote": true,
+    "trailingComma": "none"
+}

package/rust-client/node_modules/save/.travis.yml

@@ -0,0 +1,5 @@
+language: node_js
+node_js:
+  - 8
+  - 10
+  - 'lts/*'

package/rust-client/node_modules/save/LICENSE

@@ -0,0 +1,13 @@
+Copyright (c) 2015, Paul Serby <paul@serby.net>
+
+Permission to use, copy, modify, and/or distribute this software for any purpose
+with or without fee is hereby granted, provided that the above copyright notice
+and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+THIS SOFTWARE.

package/rust-client/node_modules/save/README.md

@@ -0,0 +1,137 @@
+# save - A simple CRUD based persistence abstraction for storing objects to any backend data store. eg. Memory, MongoDB, Redis, CouchDB, Postgres, Punch Card etc.
+
+[![NPM Details](https://nodei.co/npm/save.png?stars&downloads)](https://npmjs.org/package/save)
+
+[![build status](https://api.travis-ci.org/serby/save.png)](http://travis-ci.org/serby/save) [![Dependences](https://david-dm.org/serby/save.svg)](https://david-dm.org/serby/save/) [![Join the chat at https://gitter.im/serby/save](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/serby/save?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+
+**save** comes with a fully featured in memory engine which is super handy for testing your models.
+For real world use you'll need to get one of the database powered engines:
+
+* [MongoDB](https://github.com/serby/save-mongodb)
+
+If your data store of choice isn't listed here please create an engine and send me a pull request.
+To see an example of how to create an engine, please see [save-mongodb](https://github.com/serby/save-mongodb).
+
+## Installation
+
+    npm install save
+
+## Example
+
+```js
+
+var save = require('save')
+  , s = save('person')
+
+s.on('create', function() {
+  console.log('New person created!')
+})
+
+s.create({ name: 'Dom' }, function(err, person) {
+  // Outputs { name: 'Dom', _id: 1 }
+  console.log(person)
+})
+
+```
+
+## Usage
+
+```js
+var save = require('save')
+```
+
+### var s = save(name, [options])
+Save by default returns an in memory engine which means you can unit test your models independently from your database. `name` is the name of your model.
+
+Possible options are:
+
+* `idProperty`. Defaults to `_id` for mongodb
+* `logger`. Defaults to console logging: `{ info: console.info, verbose: console.info }`
+* `engine`. Persistence engine to use, defaults to memory engine: `require(./memory-engine)`
+
+### s.create(object, [cb])
+Creates a new entity.
+`cb` called with `cb(err, savedObject)`.
+
+### s.read(id, [cb])
+Reads a single entity with an `idProperty` of `id`.
+`cb` called with `cb(err, readObject)`.
+
+### s.update(object, overwrite, [cb])
+Updates a single entity. Optionally overwrites the entire entity, by default just extends it with the new values.
+`cb` called with `cb(err, readObject)`.
+
+### s.delete(id, [cb])
+Deletes one entity.
+Returns an error if the object can not be found.
+`cb` called with `cb(err)`.
+
+### s.deleteMany(query, [cb])
+Deletes entities based on a query.
+Performs a find by query, then calls delete for each item returned
+Returns an error if no items match the query.
+`cb` called with `cb(err)`.
+
+### s.find(query, options, cb)
+Performs a find on the data.
+`cb` called with `cb(err, foundObjectsArray)`.
+
+### s.findOne(query, options, cb)
+Performs a find on the data and limits the result set to 1.
+`cb` called with `cb(err, foundObject)`.
+
+### s.count(query, cb)
+Performs a count by query.
+`cb` called with `cb(err, count)`.
+
+### s.idProperty
+Provides access to the `idProperty`. Mostly used for testing.
+
+## Events
+
+### s.on('create', cb)
+This event fires with `cb(object)` where `object` is the item that will be created.
+
+### s.on('afterCreate', cb)
+This event fires with `cb(object)` where `object` is the item that has been created.
+
+### s.on('update', cb)
+This event fires with `cb(object, overwrite)` where `object` is the item that will be updated and `overwrite` is whether the object is to be overwritten or extended.
+
+### s.on('afterUpdate', cb)
+This event fires with `cb(object, overwrite)` where `object` is the item that has been updated and `overwrite` is whether the object is to be overwritten or extended.
+
+### s.on('delete', cb)
+This event fires with `cb(id)` where `id` is the item that will be deleted.
+
+### s.on('afterDelete', cb)
+This event fires with `cb(id)` where `id` is the item that has been deleted.
+
+### s.on('deleteMany', cb)
+This event fires with `cb(query)` where `query` is the query used to `deleteMany`.
+
+### s.on('afterDeleteMany', cb)
+This event fires with `cb(query)` where `query` is the query that has used `deleteMany`.
+
+### s.on('read', cb)
+This event fires with `cb(id)` where `id` is the item that has been read.
+
+### s.on('find', cb)
+This event fires with `cb(query)` where `query` is the query used to `find`.
+
+### s.on('findOne', cb)
+This event fires with `cb(query)` where `query` is the query used to `findOne`.
+
+### s.on('count', cb)
+This event fires with `cb(query)` where `query` is the query used to `count`.
+
+### s.on('error', cb)
+This event fires with `cb(err)` where `err` is any error that may have occured.
+
+## Credits
+[Paul Serby](https://github.com/serby/) follow me on twitter [@serby](http://twitter.com/serby)
+
+[Dom Harrington](https://github.com/domharrington/)
+
+## Licence
+Licenced under the [New BSD License](http://opensource.org/licenses/bsd-license.php)

package/rust-client/node_modules/save/lib/memory-engine.js

@@ -0,0 +1,340 @@
+var emptyFn = function() {}
+var Mingo = require('mingo')
+var es = require('event-stream')
+
+module.exports = function(opts) {
+  var options = Object.assign({ idProperty: '_id' }, opts)
+  var self = es.map(createOrUpdate)
+  var data = []
+  var idSeq = 0
+
+  var mingoOpts = Object.freeze({ idKey: options.idProperty })
+
+  function findById(id) {
+    var query = {}
+    query[options.idProperty] = id
+    const cursor = Mingo.find(data, query, {}, mingoOpts)
+    return cursor.hasNext() ? cursor.next() : null
+  }
+
+  /**
+   * Checks that the object has the ID property present, then checks
+   * if the data object has that ID value present.e
+   *
+   * Returns an Error to the callback if either of the above checks fail
+   *
+   * @param {Object} object to check
+   * @param {Function} callback
+   * @api private
+   */
+  function checkForIdAndData(object, callback) {
+    var id = object[options.idProperty]
+    var foundObject
+    if (id === undefined || id === null) {
+      return callback(
+        new Error("Object has no '" + options.idProperty + "' property")
+      )
+    }
+
+    foundObject = findById(id)
+
+    if (foundObject === null) {
+      return callback(
+        new Error(
+          "No object found with '" + options.idProperty + "' = '" + id + "'"
+        )
+      )
+    }
+
+    return callback(null, foundObject)
+  }
+
+  /**
+   * Create a new entity. Emits a 'create' event.
+   *
+   * @param {Object} object to create
+   * @param {Function} callback (optional)
+   * @api public
+   */
+  function create(object, callback) {
+    self.emit('create', object)
+    callback = callback || emptyFn
+    // clone the object
+    var extendedObject = Object.assign({}, object)
+
+    if (!extendedObject[options.idProperty]) {
+      idSeq += 1
+      extendedObject[options.idProperty] = '' + idSeq
+    } else {
+      if (findById(extendedObject[options.idProperty]) !== null) {
+        return callback(
+          new Error(
+            'Key ' + extendedObject[options.idProperty] + ' already exists'
+          )
+        )
+      }
+      // if an id is provided, cast to string.
+      extendedObject[options.idProperty] =
+        '' + extendedObject[options.idProperty]
+    }
+    data.push(Object.assign({}, extendedObject))
+    self.emit('afterCreate', extendedObject)
+    callback(undefined, extendedObject)
+  }
+
+  /**
+   * Create or update a entity. Emits a 'create' event or a 'update'.
+   *
+   * @param {Object} object to create or update
+   * @param {Function} callback (optional)
+   * @api public
+   */
+  function createOrUpdate(object, callback) {
+    if (typeof object[options.idProperty] === 'undefined') {
+      // Create a new object
+      self.create(object, callback)
+    } else {
+      // Try and find the object first to update
+      var query = {}
+      query[options.idProperty] = object[options.idProperty]
+
+      self.findOne(query, function(ignoreError, foundObject) {
+        if (foundObject) {
+          // We found the object so update
+          self.update(object, callback)
+        } else {
+          // We didn't find the object so create
+          self.create(object, callback)
+        }
+      })
+    }
+  }
+
+  /**
+   * Reads a single entity. Emits a 'read' event.
+   *
+   * @param {Number} id to read
+   * @param {Function} callback (optional)
+   * @api public
+   */
+  function read(id, callback) {
+    var query = {}
+
+    self.emit('read', id)
+    callback = callback || emptyFn
+    query[options.idProperty] = '' + id
+    findByQuery(query, {}, function(ignoreError, objects) {
+      if (objects[0] !== undefined) {
+        var cloned = Object.assign({}, objects[0])
+        self.emit('received', cloned)
+        callback(undefined, cloned)
+      } else {
+        callback(undefined, undefined)
+      }
+    })
+  }
+
+  /**
+   * Updates a single entity. Emits an 'update' event. Optionally overwrites
+   * the entire entity, by default just Object.assigns it with the new values.
+   *
+   * @param {Object} object to update
+   * @param {Boolean} whether to overwrite or Object.assign the existing entity
+   * @param {Function} callback (optional)
+   * @api public
+   */
+  function update(object, overwrite, callback) {
+    if (typeof overwrite === 'function') {
+      callback = overwrite
+      overwrite = false
+    }
+    self.emit('update', object, overwrite)
+    callback = callback || emptyFn
+    var id = '' + object[options.idProperty]
+    var updatedObject
+
+    checkForIdAndData(object, function(error, foundObject) {
+      if (error) {
+        return callback(error)
+      }
+
+      if (overwrite) {
+        updatedObject = Object.assign({}, object)
+      } else {
+        updatedObject = Object.assign({}, foundObject, object)
+      }
+
+      var query = {}
+      var copy = Object.assign({}, updatedObject)
+      query[options.idProperty] = id
+      data = Mingo.remove(data, query, mingoOpts)
+      data.push(updatedObject)
+      self.emit('afterUpdate', copy, overwrite)
+      callback(undefined, copy)
+    })
+  }
+
+  /**
+   * Deletes entities based on a query. Emits a 'delete' event. Performs a find
+   * by query, then calls delete for each item returned. Returns an error if no
+   * items match the query.
+   *
+   * @param {Object} query to delete on
+   * @param {Function} callback (optional)
+   * @api public
+   */
+  function deleteMany(query, callback) {
+    callback = callback || emptyFn
+    self.emit('deleteMany', query)
+    data = Mingo.remove(data, query, mingoOpts)
+    self.emit('afterDeleteMany', query)
+    callback()
+  }
+
+  /**
+   * Deletes one entity. Emits a 'delete' event. Returns an error if the
+   * object can not be found or if the ID property is not present.
+   *
+   * @param {Object} object to delete
+   * @param {Function} callback (optional)
+   * @api public
+   */
+  function del(id, callback) {
+    callback = callback || emptyFn
+
+    if (typeof callback !== 'function') {
+      throw new TypeError('callback must be a function or empty')
+    }
+
+    self.emit('delete', id)
+    var query = {}
+    query[options.idProperty] = id
+    deleteMany(query, function() {
+      self.emit('afterDelete', '' + id)
+      callback(undefined)
+    })
+  }
+
+  /**
+   * Performs a find on the data by search query.
+   *
+   * Sorting can be done similarly to mongo by providing a $sort option to
+   * the options object.
+   *
+   * The query can target fields in a subdocument similarly to mongo by passing
+   * a string reference to the subdocument in dot notation.
+   *
+   * @param {Object} query to search by
+   * @param {Object} search options
+   * @param {Function} callback
+   * @api private
+   */
+  function findByQuery(query, options, callback) {
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+
+    var cursor = Mingo.find(data, query, options && options.fields, mingoOpts)
+    if (options && options.sort) cursor = cursor.sort(options.sort)
+    if (options && options.limit) cursor = cursor.limit(options.limit)
+
+    var allData = getObjectCopies(cursor.all())
+
+    if (callback === undefined) {
+      return es.readArray(allData).pipe(
+        es.map(function(data, cb) {
+          self.emit('received', data)
+          cb(null, data)
+        })
+      )
+    } else {
+      callback(null, allData)
+    }
+  }
+
+  function getObjectCopies(objects) {
+    var copies = []
+    objects.forEach(function(object) {
+      copies.push(Object.assign({}, object))
+    })
+    return copies
+  }
+
+  /**
+   * Performs a find on the data. Emits a 'find' event.
+   *
+   * @param {Object} query to search by
+   * @param {Object} options
+   * @param {Function} callback
+   * @api public
+   */
+  function find(query, options, callback) {
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+
+    self.emit('find', query, options)
+    if (callback !== undefined) {
+      findByQuery(query, options, function(error, data) {
+        if (error) return callback(error)
+        self.emit('received', data)
+        callback(null, data)
+      })
+    } else {
+      return findByQuery(query, options)
+    }
+  }
+
+  /**
+   * Performs a find on the data and limits the result set to 1.
+   * Emits a 'findOne' event.
+   *
+   * @param {Object} query to search by
+   * @param {Object} options
+   * @param {Function} callback
+   * @api public
+   */
+  function findOne(query, options, callback) {
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    self.emit('findOne', query, options)
+    findByQuery(query, options, function(ignoreError, objects) {
+      self.emit('received', objects[0])
+      callback(undefined, objects[0])
+    })
+  }
+
+  /**
+   * Performs a count by query. Emits a 'count' event.
+   *
+   * @param {Object} query to search by
+   * @param {Function} callback
+   * @api public
+   */
+  function count(query, callback) {
+    self.emit('count', query)
+    findByQuery(query, options, function(ignoreError, objects) {
+      self.emit('received', objects.length)
+      callback(undefined, objects.length)
+    })
+  }
+
+  Object.assign(self, {
+    create: create,
+    read: read,
+    update: update,
+    delete: del,
+    deleteMany: deleteMany,
+    find: find,
+    findOne: findOne,
+    count: count,
+    idProperty: options.idProperty,
+    createOrUpdate: createOrUpdate
+  })
+
+  return self
+}

package/rust-client/node_modules/save/lib/save.js

@@ -0,0 +1,77 @@
+module.exports = function(name, opts) {
+  var engine
+  var defaults = {
+    idProperty: '_id',
+    logger: { info: console.info, verbose: console.info },
+    engine: undefined,
+    debug: true
+  }
+  var options = Object.assign({}, defaults, opts)
+
+  if (typeof name !== 'string') {
+    throw new Error("A string must be provided for 'name'")
+  }
+
+  // If no engine is passed then default to the memory engine.
+  engine =
+    options.engine ||
+    require('./memory-engine')({ idProperty: options.idProperty })
+
+  // Only log in debug mode
+  if (options.debug) {
+    engine.on('create', function(object) {
+      options.logger.info("Creating '" + name + "'", JSON.stringify(object))
+    })
+
+    engine.on('update', function(object, overwrite) {
+      options.logger.info(
+        "Updating '" + name + "'",
+        JSON.stringify(object),
+        ' with overwrite ',
+        overwrite
+      )
+    })
+
+    engine.on('updateMany', function(query) {
+      options.logger.info("Updating many '" + name + "'", JSON.stringify(query))
+    })
+
+    engine.on('delete', function(id) {
+      options.logger.info("Deleting '" + name + "'", id)
+    })
+
+    engine.on('deleteMany', function(query) {
+      options.logger.info("Deleting many '" + name + "'", JSON.stringify(query))
+    })
+
+    engine.on('read', function(id) {
+      options.logger.info("Reading '" + name + "'", id)
+    })
+
+    engine.on('find', function(query, queryOptions) {
+      options.logger.info(
+        "Finding '" + name + "'",
+        JSON.stringify(query),
+        JSON.stringify(queryOptions)
+      )
+    })
+
+    engine.on('findOne', function(query, queryOptions) {
+      options.logger.info(
+        "Finding One '" + name + "'",
+        JSON.stringify(query),
+        JSON.stringify(queryOptions)
+      )
+    })
+
+    engine.on('count', function(query) {
+      options.logger.info("Count '" + name + "'", JSON.stringify(query))
+    })
+
+    engine.on('error', function(error) {
+      options.logger.error("Error with '" + name + "'", error)
+    })
+  }
+
+  return engine
+}

package/rust-client/node_modules/save/package.json

@@ -0,0 +1,52 @@
+{
+  "author": "Paul Serby <paul@serby.net>",
+  "name": "save",
+  "description": "A simple CRUD based persistence abstraction for storing objects to any backend data store. eg. Memory, MongoDB, Redis, CouchDB, Postgres, Punch Card etc.",
+  "version": "2.9.0",
+  "tags": [
+    "data",
+    "database",
+    "ORM",
+    "it's not an ORM"
+  ],
+  "license": "ISC",
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:serby/save"
+  },
+  "publishConfig": {
+    "registry": "http://registry.npmjs.org"
+  },
+  "main": "lib/save",
+  "scripts": {
+    "lint": "eslint -f unix .",
+    "test": "nyc mocha -- --recursive -R spec -r should",
+    "prepublish": "npm test && npm prune",
+    "pretest": "npm run-script lint",
+    "prettier": "prettier --write '**/*.js'"
+  },
+  "engine": ">=6",
+  "dependencies": {
+    "async": "^3.2.2",
+    "event-stream": "^4.0.1",
+    "lodash.assign": "^4.2.0",
+    "mingo": "^6.1.0"
+  },
+  "devDependencies": {
+    "eslint": "^6.1.0",
+    "eslint-config-prettier": "^6.0.0",
+    "eslint-config-prettier-standard": "^3.0.1",
+    "eslint-config-standard": "^13.0.1",
+    "eslint-plugin-import": "^2.18.2",
+    "eslint-plugin-node": "^9.1.0",
+    "eslint-plugin-prettier": "^3.1.0",
+    "eslint-plugin-promise": "^4.2.1",
+    "eslint-plugin-standard": "^4.0.0",
+    "lodash": "^4.17.21",
+    "mocha": "^9.2.2",
+    "nyc": "^14.1.1",
+    "prettier": "^1.18.2",
+    "should": "^13.2.3",
+    "stream-assert": "^2.0.3"
+  }
+}