@valkey/valkey-glide-darwin-arm64 1.2.0-rc10 → 1.2.0-rc3

package/rust-client/node_modules/mingo/dist/esm/aggregator.js

@@ -0,0 +1,61 @@
+import {
+  getOperator,
+  initOptions,
+  OperatorType,
+  ProcessingMode
+} from "./core";
+import { Lazy } from "./lazy";
+import { assert, cloneDeep, intersection, isEmpty } from "./util";
+class Aggregator {
+  constructor(pipeline, options) {
+    this.pipeline = pipeline;
+    this.options = initOptions(options);
+  }
+  /**
+   * Returns an `Lazy` iterator for processing results of pipeline
+   *
+   * @param {*} collection An array or iterator object
+   * @returns {Iterator} an iterator object
+   */
+  stream(collection) {
+    let iterator = Lazy(collection);
+    const mode = this.options.processingMode;
+    if (mode == ProcessingMode.CLONE_ALL || mode == ProcessingMode.CLONE_INPUT) {
+      iterator.map(cloneDeep);
+    }
+    const pipelineOperators = new Array();
+    if (!isEmpty(this.pipeline)) {
+      for (const operator of this.pipeline) {
+        const operatorKeys = Object.keys(operator);
+        const opName = operatorKeys[0];
+        const call = getOperator(
+          OperatorType.PIPELINE,
+          opName,
+          this.options
+        );
+        assert(
+          operatorKeys.length === 1 && !!call,
+          `invalid pipeline operator ${opName}`
+        );
+        pipelineOperators.push(opName);
+        iterator = call(iterator, operator[opName], this.options);
+      }
+    }
+    if (mode == ProcessingMode.CLONE_OUTPUT || mode == ProcessingMode.CLONE_ALL && !!intersection([["$group", "$unwind"], pipelineOperators]).length) {
+      iterator.map(cloneDeep);
+    }
+    return iterator;
+  }
+  /**
+   * Return the results of the aggregation as an array.
+   *
+   * @param {*} collection
+   * @param {*} query
+   */
+  run(collection) {
+    return this.stream(collection).value();
+  }
+}
+export {
+  Aggregator
+};

package/rust-client/node_modules/mingo/dist/esm/core.js

@@ -0,0 +1,365 @@
+import {
+  assert,
+  has,
+  isArray,
+  isFunction,
+  isNil,
+  isObject,
+  isObjectLike,
+  isOperator,
+  isString,
+  MingoError,
+  resolve
+} from "./util";
+var ProcessingMode = /* @__PURE__ */ ((ProcessingMode2) => {
+  ProcessingMode2["CLONE_ALL"] = "CLONE_ALL";
+  ProcessingMode2["CLONE_INPUT"] = "CLONE_INPUT";
+  ProcessingMode2["CLONE_OUTPUT"] = "CLONE_OUTPUT";
+  ProcessingMode2["CLONE_OFF"] = "CLONE_OFF";
+  return ProcessingMode2;
+})(ProcessingMode || {});
+class ComputeOptions {
+  constructor(_opts, _root, _local, timestamp = Date.now()) {
+    this._opts = _opts;
+    this._root = _root;
+    this._local = _local;
+    this.timestamp = timestamp;
+    this.update(_root, _local);
+  }
+  /**
+   * Initialize new ComputeOptions.
+   *
+   * @param options
+   * @param root
+   * @param local
+   * @returns {ComputeOptions}
+   */
+  static init(options, root, local) {
+    return options instanceof ComputeOptions ? new ComputeOptions(
+      options._opts,
+      isNil(options.root) ? root : options.root,
+      Object.assign({}, options.local, local)
+    ) : new ComputeOptions(options, root, local);
+  }
+  /** Updates the internal mutable state. */
+  update(root, local) {
+    this._root = root;
+    this._local = local ? Object.assign({}, local, {
+      variables: Object.assign({}, this._local?.variables, local?.variables)
+    }) : local;
+    return this;
+  }
+  getOptions() {
+    return Object.freeze({
+      ...this._opts,
+      context: Context.from(this._opts.context)
+    });
+  }
+  get root() {
+    return this._root;
+  }
+  get local() {
+    return this._local;
+  }
+  get idKey() {
+    return this._opts.idKey;
+  }
+  get collation() {
+    return this._opts?.collation;
+  }
+  get processingMode() {
+    return this._opts?.processingMode || "CLONE_OFF" /* CLONE_OFF */;
+  }
+  get useStrictMode() {
+    return this._opts?.useStrictMode;
+  }
+  get scriptEnabled() {
+    return this._opts?.scriptEnabled;
+  }
+  get useGlobalContext() {
+    return this._opts?.useGlobalContext;
+  }
+  get hashFunction() {
+    return this._opts?.hashFunction;
+  }
+  get collectionResolver() {
+    return this._opts?.collectionResolver;
+  }
+  get jsonSchemaValidator() {
+    return this._opts?.jsonSchemaValidator;
+  }
+  get variables() {
+    return this._opts?.variables;
+  }
+  get context() {
+    return this._opts?.context;
+  }
+}
+function initOptions(options) {
+  return options instanceof ComputeOptions ? options.getOptions() : Object.freeze({
+    idKey: "_id",
+    scriptEnabled: true,
+    useStrictMode: true,
+    useGlobalContext: true,
+    processingMode: "CLONE_OFF" /* CLONE_OFF */,
+    ...options,
+    context: options?.context ? Context.from(options?.context) : Context.init({})
+  });
+}
+var OperatorType = /* @__PURE__ */ ((OperatorType2) => {
+  OperatorType2["ACCUMULATOR"] = "accumulator";
+  OperatorType2["EXPRESSION"] = "expression";
+  OperatorType2["PIPELINE"] = "pipeline";
+  OperatorType2["PROJECTION"] = "projection";
+  OperatorType2["QUERY"] = "query";
+  OperatorType2["WINDOW"] = "window";
+  return OperatorType2;
+})(OperatorType || {});
+class Context {
+  constructor(ops) {
+    this.operators = {
+      ["accumulator" /* ACCUMULATOR */]: {},
+      ["expression" /* EXPRESSION */]: {},
+      ["pipeline" /* PIPELINE */]: {},
+      ["projection" /* PROJECTION */]: {},
+      ["query" /* QUERY */]: {},
+      ["window" /* WINDOW */]: {}
+    };
+    for (const [type, operators] of Object.entries(ops)) {
+      this.addOperators(type, operators);
+    }
+  }
+  static init(ops = {}) {
+    return new Context(ops);
+  }
+  static from(ctx) {
+    return new Context(ctx.operators);
+  }
+  addOperators(type, ops) {
+    for (const [name, fn] of Object.entries(ops)) {
+      if (!this.getOperator(type, name)) {
+        this.operators[type][name] = fn;
+      }
+    }
+    return this;
+  }
+  // register
+  addAccumulatorOps(ops) {
+    return this.addOperators("accumulator" /* ACCUMULATOR */, ops);
+  }
+  addExpressionOps(ops) {
+    return this.addOperators("expression" /* EXPRESSION */, ops);
+  }
+  addQueryOps(ops) {
+    return this.addOperators("query" /* QUERY */, ops);
+  }
+  addPipelineOps(ops) {
+    return this.addOperators("pipeline" /* PIPELINE */, ops);
+  }
+  addProjectionOps(ops) {
+    return this.addOperators("projection" /* PROJECTION */, ops);
+  }
+  addWindowOps(ops) {
+    return this.addOperators("window" /* WINDOW */, ops);
+  }
+  // getters
+  getOperator(type, name) {
+    return type in this.operators ? this.operators[type][name] || null : null;
+  }
+}
+const GLOBAL_CONTEXT = Context.init();
+function useOperators(type, operators) {
+  for (const [name, fn] of Object.entries(operators)) {
+    assert(
+      isFunction(fn) && isOperator(name),
+      `'${name}' is not a valid operator`
+    );
+    const currentFn = getOperator(type, name, null);
+    assert(
+      !currentFn || fn === currentFn,
+      `${name} already exists for '${type}' operators. Cannot change operator function once registered.`
+    );
+  }
+  switch (type) {
+    case "accumulator" /* ACCUMULATOR */:
+      GLOBAL_CONTEXT.addAccumulatorOps(operators);
+      break;
+    case "expression" /* EXPRESSION */:
+      GLOBAL_CONTEXT.addExpressionOps(operators);
+      break;
+    case "pipeline" /* PIPELINE */:
+      GLOBAL_CONTEXT.addPipelineOps(operators);
+      break;
+    case "projection" /* PROJECTION */:
+      GLOBAL_CONTEXT.addProjectionOps(operators);
+      break;
+    case "query" /* QUERY */:
+      GLOBAL_CONTEXT.addQueryOps(operators);
+      break;
+    case "window" /* WINDOW */:
+      GLOBAL_CONTEXT.addWindowOps(operators);
+      break;
+  }
+}
+function getOperator(type, operator, options) {
+  const { context: ctx, useGlobalContext: fallback } = options || {};
+  const fn = ctx ? ctx.getOperator(type, operator) : null;
+  return !fn && fallback ? GLOBAL_CONTEXT.getOperator(type, operator) : fn;
+}
+const systemVariables = {
+  $$ROOT(_obj, _expr, options) {
+    return options.root;
+  },
+  $$CURRENT(obj, _expr, _options) {
+    return obj;
+  },
+  $$REMOVE(_obj, _expr, _options) {
+    return void 0;
+  },
+  $$NOW(_obj, _expr, options) {
+    return new Date(options.timestamp);
+  }
+};
+const redactVariables = {
+  $$KEEP(obj, _expr, _options) {
+    return obj;
+  },
+  $$PRUNE(_obj, _expr, _options) {
+    return void 0;
+  },
+  $$DESCEND(obj, expr, options) {
+    if (!has(expr, "$cond"))
+      return obj;
+    let result;
+    for (const [key, current] of Object.entries(obj)) {
+      if (isObjectLike(current)) {
+        if (current instanceof Array) {
+          const array = [];
+          for (let elem of current) {
+            if (isObject(elem)) {
+              elem = redact(elem, expr, options.update(elem));
+            }
+            if (!isNil(elem)) {
+              array.push(elem);
+            }
+          }
+          result = array;
+        } else {
+          result = redact(
+            current,
+            expr,
+            options.update(current)
+          );
+        }
+        if (isNil(result)) {
+          delete obj[key];
+        } else {
+          obj[key] = result;
+        }
+      }
+    }
+    return obj;
+  }
+};
+function computeValue(obj, expr, operator, options) {
+  const copts = ComputeOptions.init(options, obj);
+  operator = operator || "";
+  if (isOperator(operator)) {
+    const callExpression = getOperator(
+      "expression" /* EXPRESSION */,
+      operator,
+      options
+    );
+    if (callExpression)
+      return callExpression(obj, expr, copts);
+    const callAccumulator = getOperator(
+      "accumulator" /* ACCUMULATOR */,
+      operator,
+      options
+    );
+    if (callAccumulator) {
+      if (!(obj instanceof Array)) {
+        obj = computeValue(obj, expr, null, copts);
+        expr = null;
+      }
+      assert(obj instanceof Array, `'${operator}' target must be an array.`);
+      return callAccumulator(
+        obj,
+        expr,
+        // reset the root object for accumulators.
+        copts.update(null, copts.local)
+      );
+    }
+    throw new MingoError(`operator '${operator}' is not registered`);
+  }
+  if (isString(expr) && expr.length > 0 && expr[0] === "$") {
+    if (has(redactVariables, expr)) {
+      return expr;
+    }
+    let context = copts.root;
+    const arr = expr.split(".");
+    if (has(systemVariables, arr[0])) {
+      context = systemVariables[arr[0]](
+        obj,
+        null,
+        copts
+      );
+      expr = expr.slice(arr[0].length + 1);
+    } else if (arr[0].slice(0, 2) === "$$") {
+      context = Object.assign(
+        {},
+        copts.variables,
+        // global vars
+        // current item is added before local variables because the binding may be changed.
+        { this: obj },
+        copts.local?.variables
+        // local vars
+      );
+      const prefix = arr[0].slice(2);
+      assert(
+        has(context, prefix),
+        `Use of undefined variable: ${prefix}`
+      );
+      expr = expr.slice(2);
+    } else {
+      expr = expr.slice(1);
+    }
+    if (expr === "")
+      return context;
+    return resolve(context, expr);
+  }
+  if (isArray(expr)) {
+    return expr.map((item) => computeValue(obj, item, null, copts));
+  } else if (isObject(expr)) {
+    const result = {};
+    for (const [key, val] of Object.entries(expr)) {
+      result[key] = computeValue(obj, val, key, copts);
+      if (["expression" /* EXPRESSION */, "accumulator" /* ACCUMULATOR */].some(
+        (t) => !!getOperator(t, key, options)
+      )) {
+        assert(
+          Object.keys(expr).length === 1,
+          "Invalid aggregation expression '" + JSON.stringify(expr) + "'"
+        );
+        return result[key];
+      }
+    }
+    return result;
+  }
+  return expr;
+}
+function redact(obj, expr, options) {
+  const result = computeValue(obj, expr, null, options);
+  return has(redactVariables, result) ? redactVariables[result](obj, expr, options) : result;
+}
+export {
+  ComputeOptions,
+  Context,
+  OperatorType,
+  ProcessingMode,
+  computeValue,
+  getOperator,
+  initOptions,
+  redact,
+  useOperators
+};

package/rust-client/node_modules/mingo/dist/esm/cursor.js

@@ -0,0 +1,131 @@
+import { Aggregator } from "./aggregator";
+import { compose, Lazy } from "./lazy";
+import { isObject } from "./util";
+class Cursor {
+  constructor(source, predicate, projection, options) {
+    this.source = source;
+    this.predicate = predicate;
+    this.projection = projection;
+    this.options = options;
+    this.operators = [];
+    this.result = null;
+    this.buffer = [];
+  }
+  /** Returns the iterator from running the query */
+  fetch() {
+    if (this.result)
+      return this.result;
+    if (isObject(this.projection)) {
+      this.operators.push({ $project: this.projection });
+    }
+    this.result = Lazy(this.source).filter(this.predicate);
+    if (this.operators.length > 0) {
+      this.result = new Aggregator(this.operators, this.options).stream(
+        this.result
+      );
+    }
+    return this.result;
+  }
+  /** Returns an iterator with the buffered data included */
+  fetchAll() {
+    const buffered = Lazy([...this.buffer]);
+    this.buffer = [];
+    return compose(buffered, this.fetch());
+  }
+  /**
+   * Return remaining objects in the cursor as an array. This method exhausts the cursor
+   * @returns {Array}
+   */
+  all() {
+    return this.fetchAll().value();
+  }
+  /**
+   * Returns the number of objects return in the cursor. This method exhausts the cursor
+   * @returns {Number}
+   */
+  count() {
+    return this.all().length;
+  }
+  /**
+   * Returns a cursor that begins returning results only after passing or skipping a number of documents.
+   * @param {Number} n the number of results to skip.
+   * @return {Cursor} Returns the cursor, so you can chain this call.
+   */
+  skip(n) {
+    this.operators.push({ $skip: n });
+    return this;
+  }
+  /**
+   * Constrains the size of a cursor's result set.
+   * @param {Number} n the number of results to limit to.
+   * @return {Cursor} Returns the cursor, so you can chain this call.
+   */
+  limit(n) {
+    this.operators.push({ $limit: n });
+    return this;
+  }
+  /**
+   * Returns results ordered according to a sort specification.
+   * @param {Object} modifier an object of key and values specifying the sort order. 1 for ascending and -1 for descending
+   * @return {Cursor} Returns the cursor, so you can chain this call.
+   */
+  sort(modifier) {
+    this.operators.push({ $sort: modifier });
+    return this;
+  }
+  /**
+   * Specifies the collation for the cursor returned by the `mingo.Query.find`
+   * @param {*} spec
+   */
+  collation(spec) {
+    this.options = { ...this.options, collation: spec };
+    return this;
+  }
+  /**
+   * Returns the next document in a cursor.
+   * @returns {Object | Boolean}
+   */
+  next() {
+    if (this.buffer.length > 0) {
+      return this.buffer.pop();
+    }
+    const o = this.fetch().next();
+    if (o.done)
+      return;
+    return o.value;
+  }
+  /**
+   * Returns true if the cursor has documents and can be iterated.
+   * @returns {boolean}
+   */
+  hasNext() {
+    if (this.buffer.length > 0)
+      return true;
+    const o = this.fetch().next();
+    if (o.done)
+      return false;
+    this.buffer.push(o.value);
+    return true;
+  }
+  /**
+   * Applies a function to each document in a cursor and collects the return values in an array.
+   * @param fn
+   * @returns {Array}
+   */
+  map(fn) {
+    return this.all().map(fn);
+  }
+  /**
+   * Applies a JavaScript function for every document in a cursor.
+   * @param fn
+   */
+  forEach(fn) {
+    this.all().forEach(fn);
+  }
+  [Symbol.iterator]() {
+    return this.fetchAll();
+  }
+}
+export {
+  Cursor
+};

package/rust-client/node_modules/mingo/dist/esm/index.js

@@ -0,0 +1,29 @@
+import "./init/basic";
+import { Aggregator } from "./aggregator";
+import { Query } from "./query";
+import { Aggregator as Aggregator2 } from "./aggregator";
+import { Query as Query2 } from "./query";
+function find(collection, criteria, projection, options) {
+  return new Query(criteria, options).find(collection, projection);
+}
+function remove(collection, criteria, options) {
+  return new Query(criteria, options).remove(collection);
+}
+function aggregate(collection, pipeline, options) {
+  return new Aggregator(pipeline, options).run(collection);
+}
+var src_default = {
+  Aggregator,
+  Query,
+  aggregate,
+  find,
+  remove
+};
+export {
+  Aggregator2 as Aggregator,
+  Query2 as Query,
+  aggregate,
+  src_default as default,
+  find,
+  remove
+};

package/rust-client/node_modules/mingo/dist/esm/init/basic.js

@@ -0,0 +1,25 @@
+import { Context, OperatorType, useOperators } from "../core";
+import * as booleanOperators from "../operators/expression/boolean";
+import * as comparisonOperators from "../operators/expression/comparison";
+import { $limit, $project, $skip, $sort } from "../operators/pipeline";
+import * as projectionOperators from "../operators/projection";
+import * as queryOperators from "../operators/query";
+useOperators(OperatorType.EXPRESSION, {
+  ...booleanOperators,
+  ...comparisonOperators
+});
+useOperators(OperatorType.PIPELINE, {
+  $project,
+  $skip,
+  $limit,
+  $sort
+});
+useOperators(OperatorType.PROJECTION, projectionOperators);
+useOperators(OperatorType.QUERY, queryOperators);
+const BASIC_CONTEXT = Context.init().addExpressionOps({
+  ...booleanOperators,
+  ...comparisonOperators
+}).addPipelineOps({ $project, $skip, $limit, $sort }).addProjectionOps(projectionOperators).addQueryOps(queryOperators);
+export {
+  BASIC_CONTEXT
+};

package/rust-client/node_modules/mingo/dist/esm/init/system.js

@@ -0,0 +1,13 @@
+import { OperatorType, useOperators } from "../core";
+import * as accumulatorOperators from "../operators/accumulator";
+import * as expressionOperators from "../operators/expression";
+import * as pipelineOperators from "../operators/pipeline";
+import * as projectionOperators from "../operators/projection";
+import * as queryOperators from "../operators/query";
+import * as windowOperators from "../operators/window";
+useOperators(OperatorType.ACCUMULATOR, accumulatorOperators);
+useOperators(OperatorType.EXPRESSION, expressionOperators);
+useOperators(OperatorType.PIPELINE, pipelineOperators);
+useOperators(OperatorType.PROJECTION, projectionOperators);
+useOperators(OperatorType.QUERY, queryOperators);
+useOperators(OperatorType.WINDOW, windowOperators);