@valkey/valkey-glide-darwin-arm64 1.2.0 → 1.2.1-rc0

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

@@ -37,12 +37,13 @@ var ProcessingMode = /* @__PURE__ */ ((ProcessingMode2) => {
   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);
+  #options;
+  /** Reference to the root object when processing subgraphs of the object. */
+  #root;
+  #local;
+  constructor(options, root, local) {
+    this.#options = options;
+    this.update(root, local);
   }
   /**
    * Initialize new ComputeOptions.
@@ -53,64 +54,82 @@ class ComputeOptions {
    * @returns {ComputeOptions}
    */
   static init(options, root, local) {
-    return options instanceof ComputeOptions ? new ComputeOptions(
-      options._opts,
-      (0, import_util.isNil)(options.root) ? root : options.root,
-      Object.assign({}, options.local, local)
-    ) : new ComputeOptions(options, root, local);
+    return options instanceof ComputeOptions ? new ComputeOptions(options.#options, options.root ?? root, {
+      ...options.#local,
+      ...local,
+      // retain existing variables
+      variables: Object.assign(
+        {},
+        options.#local?.variables,
+        local?.variables
+      )
+    }) : new ComputeOptions(options, root, local);
   }
-  /** Updates the internal mutable state. */
+  /**
+   * Updates the internal state.
+   *
+   * @param root The new root context for this object.
+   * @param local The new local state to merge into current if it exists.
+   * @returns
+   */
   update(root, local) {
-    this._root = root;
-    this._local = local ? Object.assign({}, local, {
-      variables: Object.assign({}, this._local?.variables, local?.variables)
-    }) : local;
+    this.#root = root;
+    const variables = Object.assign(
+      {},
+      this.#local?.variables,
+      local?.variables
+    );
+    if (Object.keys(variables).length) {
+      this.#local = { ...local, variables };
+    } else {
+      this.#local = local ?? {};
+    }
     return this;
   }
   getOptions() {
     return Object.freeze({
-      ...this._opts,
-      context: Context.from(this._opts.context)
+      ...this.#options,
+      context: Context.from(this.#options.context)
     });
   }
   get root() {
-    return this._root;
+    return this.#root;
   }
   get local() {
-    return this._local;
+    return this.#local;
   }
   get idKey() {
-    return this._opts.idKey;
+    return this.#options.idKey;
   }
   get collation() {
-    return this._opts?.collation;
+    return this.#options?.collation;
   }
   get processingMode() {
-    return this._opts?.processingMode || "CLONE_OFF" /* CLONE_OFF */;
+    return this.#options?.processingMode || "CLONE_OFF" /* CLONE_OFF */;
   }
   get useStrictMode() {
-    return this._opts?.useStrictMode;
+    return this.#options?.useStrictMode;
   }
   get scriptEnabled() {
-    return this._opts?.scriptEnabled;
+    return this.#options?.scriptEnabled;
   }
   get useGlobalContext() {
-    return this._opts?.useGlobalContext;
+    return this.#options?.useGlobalContext;
   }
   get hashFunction() {
-    return this._opts?.hashFunction;
+    return this.#options?.hashFunction;
   }
   get collectionResolver() {
-    return this._opts?.collectionResolver;
+    return this.#options?.collectionResolver;
   }
   get jsonSchemaValidator() {
-    return this._opts?.jsonSchemaValidator;
+    return this.#options?.jsonSchemaValidator;
   }
   get variables() {
-    return this._opts?.variables;
+    return this.#options?.variables;
   }
   get context() {
-    return this._opts?.context;
+    return this.#options?.context;
   }
 }
 function initOptions(options) {
@@ -121,7 +140,7 @@ function initOptions(options) {
     useGlobalContext: true,
     processingMode: "CLONE_OFF" /* CLONE_OFF */,
     ...options,
-    context: options?.context ? Context.from(options?.context) : Context.init({})
+    context: options?.context ? Context.from(options?.context) : Context.init()
   });
 }
 var OperatorType = /* @__PURE__ */ ((OperatorType2) => {
@@ -134,55 +153,48 @@ var OperatorType = /* @__PURE__ */ ((OperatorType2) => {
   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);
-    }
+  #operators = /* @__PURE__ */ new Map();
+  constructor() {
   }
-  static init(ops = {}) {
-    return new Context(ops);
+  static init() {
+    return new Context();
   }
   static from(ctx) {
-    return new Context(ctx.operators);
-  }
-  addOperators(type, ops) {
-    for (const [name, fn] of Object.entries(ops)) {
+    const instance = Context.init();
+    if ((0, import_util.isNil)(ctx)) return instance;
+    ctx.#operators.forEach((v, k) => instance.addOperators(k, v));
+    return instance;
+  }
+  addOperators(type, operators) {
+    if (!this.#operators.has(type)) this.#operators.set(type, {});
+    for (const [name, fn] of Object.entries(operators)) {
       if (!this.getOperator(type, name)) {
-        this.operators[type][name] = fn;
+        this.#operators.get(type)[name] = fn;
       }
     }
     return this;
   }
-  // register
+  getOperator(type, name) {
+    const ops = this.#operators.get(type) ?? {};
+    return ops[name] ?? null;
+  }
   addAccumulatorOps(ops) {
-    return this.addOperators("accumulator" /* ACCUMULATOR */, ops);
+    return this.addOperators("accumulator", ops);
   }
   addExpressionOps(ops) {
-    return this.addOperators("expression" /* EXPRESSION */, ops);
+    return this.addOperators("expression", ops);
   }
   addQueryOps(ops) {
-    return this.addOperators("query" /* QUERY */, ops);
+    return this.addOperators("query", ops);
   }
   addPipelineOps(ops) {
-    return this.addOperators("pipeline" /* PIPELINE */, ops);
+    return this.addOperators("pipeline", ops);
   }
   addProjectionOps(ops) {
-    return this.addOperators("projection" /* PROJECTION */, ops);
+    return this.addOperators("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;
+    return this.addOperators("window", ops);
   }
 }
 const GLOBAL_CONTEXT = Context.init();
@@ -199,176 +211,153 @@ function useOperators(type, operators) {
     );
   }
   switch (type) {
-    case "accumulator" /* ACCUMULATOR */:
+    case "accumulator":
       GLOBAL_CONTEXT.addAccumulatorOps(operators);
       break;
-    case "expression" /* EXPRESSION */:
+    case "expression":
       GLOBAL_CONTEXT.addExpressionOps(operators);
       break;
-    case "pipeline" /* PIPELINE */:
+    case "pipeline":
       GLOBAL_CONTEXT.addPipelineOps(operators);
       break;
-    case "projection" /* PROJECTION */:
+    case "projection":
       GLOBAL_CONTEXT.addProjectionOps(operators);
       break;
-    case "query" /* QUERY */:
+    case "query":
       GLOBAL_CONTEXT.addQueryOps(operators);
       break;
-    case "window" /* WINDOW */:
+    case "window":
       GLOBAL_CONTEXT.addWindowOps(operators);
       break;
   }
 }
-function getOperator(type, operator, options) {
+function getOperator(type, name, 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 fn = ctx ? ctx.getOperator(type, name) : null;
+  return !fn && fallback ? GLOBAL_CONTEXT.getOperator(type, name) : 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 (!(0, import_util.has)(expr, "$cond"))
-      return obj;
-    let result;
-    for (const [key, current] of Object.entries(obj)) {
-      if ((0, import_util.isObjectLike)(current)) {
-        if (current instanceof Array) {
-          const array = [];
-          for (let elem of current) {
-            if ((0, import_util.isObject)(elem)) {
-              elem = redact(elem, expr, options.update(elem));
-            }
-            if (!(0, import_util.isNil)(elem)) {
-              array.push(elem);
-            }
-          }
-          result = array;
-        } else {
-          result = redact(
-            current,
-            expr,
-            options.update(current)
-          );
-        }
-        if ((0, import_util.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 ((0, import_util.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;
-      }
-      (0, import_util.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 import_util.MingoError(`operator '${operator}' is not registered`);
-  }
+  return !!operator && (0, import_util.isOperator)(operator) ? computeOperator(obj, expr, operator, copts) : computeExpression(obj, expr, copts);
+}
+const SYSTEM_VARS = ["$$ROOT", "$$CURRENT", "$$REMOVE", "$$NOW"];
+function computeExpression(obj, expr, options) {
   if ((0, import_util.isString)(expr) && expr.length > 0 && expr[0] === "$") {
-    if ((0, import_util.has)(redactVariables, expr)) {
-      return expr;
-    }
-    let context = copts.root;
+    if (REDACT_ACTIONS.includes(expr)) return expr;
+    let ctx = options.root;
     const arr = expr.split(".");
-    if ((0, import_util.has)(systemVariables, arr[0])) {
-      context = systemVariables[arr[0]](
-        obj,
-        null,
-        copts
-      );
+    if (SYSTEM_VARS.includes(arr[0])) {
+      switch (arr[0]) {
+        case "$$ROOT":
+          break;
+        case "$$CURRENT":
+          ctx = obj;
+          break;
+        case "$$REMOVE":
+          ctx = void 0;
+          break;
+        case "$$NOW":
+          ctx = /* @__PURE__ */ new Date();
+          break;
+      }
       expr = expr.slice(arr[0].length + 1);
     } else if (arr[0].slice(0, 2) === "$$") {
-      context = Object.assign(
+      ctx = Object.assign(
         {},
-        copts.variables,
         // global vars
+        options.variables,
         // current item is added before local variables because the binding may be changed.
         { this: obj },
-        copts.local?.variables
         // local vars
+        options?.local?.variables
       );
-      const prefix = arr[0].slice(2);
-      (0, import_util.assert)(
-        (0, import_util.has)(context, prefix),
-        `Use of undefined variable: ${prefix}`
-      );
+      const name = arr[0].slice(2);
+      (0, import_util.assert)((0, import_util.has)(ctx, name), `Use of undefined variable: ${name}`);
       expr = expr.slice(2);
     } else {
       expr = expr.slice(1);
     }
-    if (expr === "")
-      return context;
-    return (0, import_util.resolve)(context, expr);
+    return expr === "" ? ctx : (0, import_util.resolve)(ctx, expr);
   }
   if ((0, import_util.isArray)(expr)) {
-    return expr.map((item) => computeValue(obj, item, null, copts));
-  } else if ((0, import_util.isObject)(expr)) {
+    return expr.map((item) => computeExpression(obj, item, options));
+  }
+  if ((0, import_util.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)
-      )) {
-        (0, import_util.assert)(
-          Object.keys(expr).length === 1,
-          "Invalid aggregation expression '" + JSON.stringify(expr) + "'"
-        );
-        return result[key];
+    const elems = Object.entries(expr);
+    for (const [key, val] of elems) {
+      if ((0, import_util.isOperator)(key)) {
+        (0, import_util.assert)(elems.length == 1, "expression must have single operator.");
+        return computeOperator(obj, val, key, options);
       }
+      result[key] = computeExpression(obj, val, options);
     }
     return result;
   }
   return expr;
 }
+function computeOperator(obj, expr, operator, options) {
+  const callExpression = getOperator(
+    "expression",
+    operator,
+    options
+  );
+  if (callExpression) return callExpression(obj, expr, options);
+  const callAccumulator = getOperator(
+    "accumulator",
+    operator,
+    options
+  );
+  (0, import_util.assert)(!!callAccumulator, `accumulator '${operator}' is not registered.`);
+  if (!(0, import_util.isArray)(obj)) {
+    obj = computeExpression(obj, expr, options);
+    expr = null;
+  }
+  (0, import_util.assert)((0, import_util.isArray)(obj), `arguments must resolve to array for ${operator}.`);
+  return callAccumulator(
+    obj,
+    expr,
+    options.update(null, options.local)
+    // reset the root object.
+  );
+}
+const REDACT_ACTIONS = ["$$KEEP", "$$PRUNE", "$$DESCEND"];
 function redact(obj, expr, options) {
-  const result = computeValue(obj, expr, null, options);
-  return (0, import_util.has)(redactVariables, result) ? redactVariables[result](obj, expr, options) : result;
+  const action = computeValue(obj, expr, null, options);
+  switch (action) {
+    case "$$KEEP":
+      return obj;
+    case "$$PRUNE":
+      return void 0;
+    case "$$DESCEND": {
+      if (!(0, import_util.has)(expr, "$cond")) return obj;
+      const output = {};
+      for (const [key, value] of Object.entries(obj)) {
+        if ((0, import_util.isArray)(value)) {
+          const res = new Array();
+          for (let elem of value) {
+            if ((0, import_util.isObject)(elem)) {
+              elem = redact(elem, expr, options.update(elem));
+            }
+            if (!(0, import_util.isNil)(elem)) res.push(elem);
+          }
+          output[key] = res;
+        } else if ((0, import_util.isObject)(value)) {
+          const res = redact(
+            value,
+            expr,
+            options.update(value)
+          );
+          if (!(0, import_util.isNil)(res)) output[key] = res;
+        } else {
+          output[key] = value;
+        }
+      }
+      return output;
+    }
+    default:
+      return action;
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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

@@ -24,35 +24,38 @@ var import_aggregator = require("./aggregator");
 var import_lazy = require("./lazy");
 var import_util = require("./util");
 class Cursor {
+  #source;
+  #predicate;
+  #projection;
+  #options;
+  #operators = [];
+  #result = null;
+  #buffer = [];
   constructor(source, predicate, projection, options) {
-    this.source = source;
-    this.predicate = predicate;
-    this.projection = projection;
-    this.options = options;
-    this.operators = [];
-    this.result = null;
-    this.buffer = [];
+    this.#source = source;
+    this.#predicate = predicate;
+    this.#projection = projection;
+    this.#options = options;
   }
   /** Returns the iterator from running the query */
   fetch() {
-    if (this.result)
-      return this.result;
-    if ((0, import_util.isObject)(this.projection)) {
-      this.operators.push({ $project: this.projection });
+    if (this.#result) return this.#result;
+    if ((0, import_util.isObject)(this.#projection)) {
+      this.#operators.push({ $project: this.#projection });
     }
-    this.result = (0, import_lazy.Lazy)(this.source).filter(this.predicate);
-    if (this.operators.length > 0) {
-      this.result = new import_aggregator.Aggregator(this.operators, this.options).stream(
-        this.result
+    this.#result = (0, import_lazy.Lazy)(this.#source).filter(this.#predicate);
+    if (this.#operators.length > 0) {
+      this.#result = new import_aggregator.Aggregator(this.#operators, this.#options).stream(
+        this.#result
       );
     }
-    return this.result;
+    return this.#result;
   }
   /** Returns an iterator with the buffered data included */
   fetchAll() {
-    const buffered = (0, import_lazy.Lazy)([...this.buffer]);
-    this.buffer = [];
-    return (0, import_lazy.compose)(buffered, this.fetch());
+    const buffered = (0, import_lazy.Lazy)([...this.#buffer]);
+    this.#buffer = [];
+    return (0, import_lazy.concat)(buffered, this.fetch());
   }
   /**
    * Return remaining objects in the cursor as an array. This method exhausts the cursor
@@ -74,7 +77,7 @@ class Cursor {
    * @return {Cursor} Returns the cursor, so you can chain this call.
    */
   skip(n) {
-    this.operators.push({ $skip: n });
+    this.#operators.push({ $skip: n });
     return this;
   }
   /**
@@ -83,16 +86,16 @@ class Cursor {
    * @return {Cursor} Returns the cursor, so you can chain this call.
    */
   limit(n) {
-    this.operators.push({ $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
+   * @param {AnyObject} 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 });
+    this.#operators.push({ $sort: modifier });
     return this;
   }
   /**
@@ -100,20 +103,19 @@ class Cursor {
    * @param {*} spec
    */
   collation(spec) {
-    this.options = { ...this.options, collation: spec };
+    this.#options = { ...this.#options, collation: spec };
     return this;
   }
   /**
    * Returns the next document in a cursor.
-   * @returns {Object | Boolean}
+   * @returns {AnyObject | Boolean}
    */
   next() {
-    if (this.buffer.length > 0) {
-      return this.buffer.pop();
+    if (this.#buffer.length > 0) {
+      return this.#buffer.pop();
     }
     const o = this.fetch().next();
-    if (o.done)
-      return;
+    if (o.done) return;
     return o.value;
   }
   /**
@@ -121,12 +123,10 @@ class Cursor {
    * @returns {boolean}
    */
   hasNext() {
-    if (this.buffer.length > 0)
-      return true;
+    if (this.#buffer.length > 0) return true;
     const o = this.fetch().next();
-    if (o.done)
-      return false;
-    this.buffer.push(o.value);
+    if (o.done) return false;
+    this.#buffer.push(o.value);
     return true;
   }
   /**

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

@@ -20,16 +20,20 @@ __export(src_exports, {
   Aggregator: () => import_aggregator2.Aggregator,
   Query: () => import_query2.Query,
   aggregate: () => aggregate,
+  createUpdater: () => import_updater2.createUpdater,
   default: () => src_default,
   find: () => find,
-  remove: () => remove
+  remove: () => remove,
+  update: () => import_updater2.update
 });
 module.exports = __toCommonJS(src_exports);
 var import_basic = require("./init/basic");
 var import_aggregator = require("./aggregator");
 var import_query = require("./query");
+var import_updater = require("./updater");
 var import_aggregator2 = require("./aggregator");
 var import_query2 = require("./query");
+var import_updater2 = require("./updater");
 function find(collection, criteria, projection, options) {
   return new import_query.Query(criteria, options).find(collection, projection);
 }
@@ -43,14 +47,18 @@ var src_default = {
   Aggregator: import_aggregator.Aggregator,
   Query: import_query.Query,
   aggregate,
+  createUpdater: import_updater.createUpdater,
   find,
-  remove
+  remove,
+  update: import_updater.update
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Aggregator,
   Query,
   aggregate,
+  createUpdater,
   find,
-  remove
+  remove,
+  update
 });