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

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

@@ -1,47 +1,45 @@
 import {
   getOperator,
   initOptions,
-  OperatorType,
   ProcessingMode
 } from "./core";
 import { Lazy } from "./lazy";
 import { assert, cloneDeep, intersection, isEmpty } from "./util";
 class Aggregator {
+  #pipeline;
+  #options;
   constructor(pipeline, options) {
-    this.pipeline = pipeline;
-    this.options = initOptions(options);
+    this.#pipeline = pipeline;
+    this.#options = initOptions(options);
   }
   /**
-   * Returns an `Lazy` iterator for processing results of pipeline
+   * Returns an {@link Iterator} for lazy evaluation of the pipeline.
    *
    * @param {*} collection An array or iterator object
    * @returns {Iterator} an iterator object
    */
-  stream(collection) {
+  stream(collection, options) {
     let iterator = Lazy(collection);
-    const mode = this.options.processingMode;
+    const opts = options ?? this.#options;
+    const mode = opts.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 stages = 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
-        );
+        const call = getOperator("pipeline", opName, opts);
         assert(
           operatorKeys.length === 1 && !!call,
           `invalid pipeline operator ${opName}`
         );
-        pipelineOperators.push(opName);
-        iterator = call(iterator, operator[opName], this.options);
+        stages.push(opName);
+        iterator = call(iterator, operator[opName], opts);
       }
     }
-    if (mode == ProcessingMode.CLONE_OUTPUT || mode == ProcessingMode.CLONE_ALL && !!intersection([["$group", "$unwind"], pipelineOperators]).length) {
+    if (mode == ProcessingMode.CLONE_OUTPUT || mode == ProcessingMode.CLONE_ALL && !!intersection([["$group", "$unwind"], stages]).length) {
       iterator.map(cloneDeep);
     }
     return iterator;
@@ -49,11 +47,10 @@ class Aggregator {
   /**
    * Return the results of the aggregation as an array.
    *
-   * @param {*} collection
-   * @param {*} query
+   * @param collection
    */
-  run(collection) {
-    return this.stream(collection).value();
+  run(collection, options) {
+    return this.stream(collection, options).value();
   }
 }
 export {

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

@@ -5,10 +5,8 @@ import {
   isFunction,
   isNil,
   isObject,
-  isObjectLike,
   isOperator,
   isString,
-  MingoError,
   resolve
 } from "./util";
 var ProcessingMode = /* @__PURE__ */ ((ProcessingMode2) => {
@@ -19,12 +17,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.
@@ -35,64 +34,82 @@ class ComputeOptions {
    * @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);
+    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) {
@@ -103,7 +120,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) => {
@@ -116,55 +133,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 (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();
@@ -181,176 +191,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 (!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`);
-  }
+  return !!operator && isOperator(operator) ? computeOperator(obj, expr, operator, copts) : computeExpression(obj, expr, copts);
+}
+const SYSTEM_VARS = ["$$ROOT", "$$CURRENT", "$$REMOVE", "$$NOW"];
+function computeExpression(obj, expr, options) {
   if (isString(expr) && expr.length > 0 && expr[0] === "$") {
-    if (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 (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);
-      assert(
-        has(context, prefix),
-        `Use of undefined variable: ${prefix}`
-      );
+      const name = arr[0].slice(2);
+      assert(has(ctx, name), `Use of undefined variable: ${name}`);
       expr = expr.slice(2);
     } else {
       expr = expr.slice(1);
     }
-    if (expr === "")
-      return context;
-    return resolve(context, expr);
+    return expr === "" ? ctx : resolve(ctx, expr);
   }
   if (isArray(expr)) {
-    return expr.map((item) => computeValue(obj, item, null, copts));
-  } else if (isObject(expr)) {
+    return expr.map((item) => computeExpression(obj, item, options));
+  }
+  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];
+    const elems = Object.entries(expr);
+    for (const [key, val] of elems) {
+      if (isOperator(key)) {
+        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
+  );
+  assert(!!callAccumulator, `accumulator '${operator}' is not registered.`);
+  if (!isArray(obj)) {
+    obj = computeExpression(obj, expr, options);
+    expr = null;
+  }
+  assert(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 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 (!has(expr, "$cond")) return obj;
+      const output = {};
+      for (const [key, value] of Object.entries(obj)) {
+        if (isArray(value)) {
+          const res = new Array();
+          for (let elem of value) {
+            if (isObject(elem)) {
+              elem = redact(elem, expr, options.update(elem));
+            }
+            if (!isNil(elem)) res.push(elem);
+          }
+          output[key] = res;
+        } else if (isObject(value)) {
+          const res = redact(
+            value,
+            expr,
+            options.update(value)
+          );
+          if (!isNil(res)) output[key] = res;
+        } else {
+          output[key] = value;
+        }
+      }
+      return output;
+    }
+    default:
+      return action;
+  }
 }
 export {
   ComputeOptions,