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

package/rust-client/node_modules/mingo/dist/esm/operators/pipeline/group.js

@@ -0,0 +1,44 @@
+import {
+  ComputeOptions,
+  computeValue
+} from "../../core";
+import { assert, groupBy, has } from "../../util";
+const ID_KEY = "_id";
+const $group = (collection, expr, options) => {
+  assert(has(expr, ID_KEY), "a group specification must include an _id");
+  const idExpr = expr[ID_KEY];
+  const copts = ComputeOptions.init(options);
+  return collection.transform((coll) => {
+    const partitions = groupBy(
+      coll,
+      (obj) => computeValue(obj, idExpr, null, options),
+      options.hashFunction
+    );
+    expr = { ...expr };
+    delete expr[ID_KEY];
+    let i = -1;
+    const partitionKeys = Array.from(partitions.keys());
+    const size = partitions.size;
+    return () => {
+      if (++i === size)
+        return { done: true };
+      const groupId = partitionKeys[i];
+      const obj = {};
+      if (groupId !== void 0) {
+        obj[ID_KEY] = groupId;
+      }
+      for (const [key, val] of Object.entries(expr)) {
+        obj[key] = computeValue(
+          partitions.get(groupId),
+          val,
+          key,
+          copts.update(null, { groupId })
+        );
+      }
+      return { value: obj, done: false };
+    };
+  });
+};
+export {
+  $group
+};

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

@@ -0,0 +1,25 @@
+export * from "./addFields";
+export * from "./bucket";
+export * from "./bucketAuto";
+export * from "./count";
+export * from "./facet";
+export * from "./fill";
+export * from "./group";
+export * from "./limit";
+export * from "./lookup";
+export * from "./match";
+export * from "./merge";
+export * from "./out";
+export * from "./project";
+export * from "./redact";
+export * from "./replaceRoot";
+export * from "./replaceWith";
+export * from "./sample";
+export * from "./set";
+export * from "./setWindowFields";
+export * from "./skip";
+export * from "./sort";
+export * from "./sortByCount";
+export * from "./unionWith";
+export * from "./unset";
+export * from "./unwind";

package/rust-client/node_modules/mingo/dist/esm/operators/pipeline/limit.js

@@ -0,0 +1,6 @@
+const $limit = (collection, expr, options) => {
+  return collection.take(expr);
+};
+export {
+  $limit
+};

package/rust-client/node_modules/mingo/dist/esm/operators/pipeline/lookup.js

@@ -0,0 +1,20 @@
+import { assert, hashCode, into, isString, resolve } from "../../util";
+const $lookup = (collection, expr, options) => {
+  const joinColl = isString(expr.from) ? options?.collectionResolver(expr.from) : expr.from;
+  assert(joinColl instanceof Array, `'from' field must resolve to an array`);
+  const hash = {};
+  for (const obj of joinColl) {
+    const k = hashCode(resolve(obj, expr.foreignField), options?.hashFunction);
+    hash[k] = hash[k] || [];
+    hash[k].push(obj);
+  }
+  return collection.map((obj) => {
+    const k = hashCode(resolve(obj, expr.localField), options?.hashFunction);
+    const newObj = into({}, obj);
+    newObj[expr.as] = hash[k] || [];
+    return newObj;
+  });
+};
+export {
+  $lookup
+};

package/rust-client/node_modules/mingo/dist/esm/operators/pipeline/match.js

@@ -0,0 +1,8 @@
+import { Query } from "../../query";
+const $match = (collection, expr, options) => {
+  const q = new Query(expr, options);
+  return collection.filter((o) => q.test(o));
+};
+export {
+  $match
+};

package/rust-client/node_modules/mingo/dist/esm/operators/pipeline/merge.js

@@ -0,0 +1,95 @@
+import { Aggregator } from "../../aggregator";
+import {
+  ComputeOptions,
+  computeValue
+} from "../../core";
+import {
+  assert,
+  hashCode,
+  isArray,
+  isString,
+  MingoError,
+  resolve
+} from "../../util";
+import { $mergeObjects } from "../expression";
+const $merge = (collection, expr, options) => {
+  const output = isString(expr.into) ? options?.collectionResolver(expr.into) : expr.into;
+  assert(
+    output instanceof Array,
+    `$merge: option 'into' must resolve to an array`
+  );
+  const onField = expr.on || options.idKey;
+  const getHash = (o) => {
+    const val = isString(onField) ? resolve(o, onField) : onField.map((s) => resolve(o, s));
+    return hashCode(val, options.hashFunction);
+  };
+  const hash = {};
+  for (let i = 0; i < output.length; i++) {
+    const obj = output[i];
+    const k = getHash(obj);
+    assert(
+      !hash[k],
+      "$merge: 'into' collection must have unique entries for the 'on' field."
+    );
+    hash[k] = [obj, i];
+  }
+  const copts = ComputeOptions.init(options);
+  return collection.map((o) => {
+    const k = getHash(o);
+    if (hash[k]) {
+      const [target, i] = hash[k];
+      const variables = computeValue(
+        target,
+        expr.let || { new: "$$ROOT" },
+        null,
+        // 'root' is the item from the iteration.
+        copts.update(o)
+      );
+      if (isArray(expr.whenMatched)) {
+        const aggregator = new Aggregator(expr.whenMatched, {
+          ...options,
+          variables
+        });
+        output[i] = aggregator.run([target])[0];
+      } else {
+        switch (expr.whenMatched) {
+          case "replace":
+            output[i] = o;
+            break;
+          case "fail":
+            throw new MingoError(
+              "$merge: failed due to matching as specified by 'whenMatched' option."
+            );
+          case "keepExisting":
+            break;
+          case "merge":
+          default:
+            output[i] = $mergeObjects(
+              target,
+              [target, o],
+              // 'root' is the item from the iteration.
+              copts.update(o, { variables })
+            );
+            break;
+        }
+      }
+    } else {
+      switch (expr.whenNotMatched) {
+        case "discard":
+          break;
+        case "fail":
+          throw new MingoError(
+            "$merge: failed due to matching as specified by 'whenMatched' option."
+          );
+        case "insert":
+        default:
+          output.push(o);
+          break;
+      }
+    }
+    return o;
+  });
+};
+export {
+  $merge
+};

package/rust-client/node_modules/mingo/dist/esm/operators/pipeline/out.js

@@ -0,0 +1,12 @@
+import { assert, cloneDeep, isString } from "../../util";
+const $out = (collection, expr, options) => {
+  const outputColl = isString(expr) ? options?.collectionResolver(expr) : expr;
+  assert(outputColl instanceof Array, `expression must resolve to an array`);
+  return collection.map((o) => {
+    outputColl.push(cloneDeep(o));
+    return o;
+  });
+};
+export {
+  $out
+};

package/rust-client/node_modules/mingo/dist/esm/operators/pipeline/project.js

@@ -0,0 +1,170 @@
+import {
+  ComputeOptions,
+  computeValue,
+  getOperator,
+  OperatorType
+} from "../../core";
+import {
+  assert,
+  ensureArray,
+  filterMissing,
+  has,
+  inArray,
+  into,
+  isEmpty,
+  isNil,
+  isNumber,
+  isObject,
+  isOperator,
+  isString,
+  merge,
+  notInArray,
+  removeValue,
+  resolveGraph,
+  setValue
+} from "../../util";
+const $project = (collection, expr, options) => {
+  if (isEmpty(expr))
+    return collection;
+  let expressionKeys = Object.keys(expr);
+  let idOnlyExcluded = false;
+  validateExpression(expr, options);
+  const ID_KEY = options.idKey;
+  if (inArray(expressionKeys, ID_KEY)) {
+    const id = expr[ID_KEY];
+    if (id === 0 || id === false) {
+      expressionKeys = expressionKeys.filter(
+        notInArray.bind(null, [ID_KEY])
+      );
+      idOnlyExcluded = expressionKeys.length == 0;
+    }
+  } else {
+    expressionKeys.push(ID_KEY);
+  }
+  const copts = ComputeOptions.init(options);
+  return collection.map((obj) => processObject(
+    obj,
+    expr,
+    copts.update(obj),
+    expressionKeys,
+    idOnlyExcluded
+  ));
+};
+function processObject(obj, expr, options, expressionKeys, idOnlyExcluded) {
+  let newObj = {};
+  let foundSlice = false;
+  let foundExclusion = false;
+  const dropKeys = [];
+  if (idOnlyExcluded) {
+    dropKeys.push(options.idKey);
+  }
+  for (const key of expressionKeys) {
+    let value = void 0;
+    const subExpr = expr[key];
+    if (key !== options.idKey && inArray([0, false], subExpr)) {
+      foundExclusion = true;
+    }
+    if (key === options.idKey && isEmpty(subExpr)) {
+      value = obj[key];
+    } else if (isString(subExpr)) {
+      value = computeValue(obj, subExpr, key, options);
+    } else if (inArray([1, true], subExpr)) {
+    } else if (subExpr instanceof Array) {
+      value = subExpr.map((v) => {
+        const r = computeValue(obj, v, null, options);
+        if (isNil(r))
+          return null;
+        return r;
+      });
+    } else if (isObject(subExpr)) {
+      const subExprObj = subExpr;
+      const subExprKeys = Object.keys(subExpr);
+      const operator = subExprKeys.length == 1 ? subExprKeys[0] : "";
+      const call = getOperator(
+        OperatorType.PROJECTION,
+        operator,
+        options
+      );
+      if (call) {
+        if (operator === "$slice") {
+          if (ensureArray(subExprObj[operator]).every(isNumber)) {
+            value = call(obj, subExprObj[operator], key, options);
+            foundSlice = true;
+          } else {
+            value = computeValue(obj, subExprObj, key, options);
+          }
+        } else {
+          value = call(obj, subExprObj[operator], key, options);
+        }
+      } else if (isOperator(operator)) {
+        value = computeValue(obj, subExprObj[operator], operator, options);
+      } else if (has(obj, key)) {
+        validateExpression(subExprObj, options);
+        let target = obj[key];
+        if (target instanceof Array) {
+          value = target.map(
+            (o) => processObject(o, subExprObj, options, subExprKeys, false)
+          );
+        } else {
+          target = isObject(target) ? target : obj;
+          value = processObject(
+            target,
+            subExprObj,
+            options,
+            subExprKeys,
+            false
+          );
+        }
+      } else {
+        value = computeValue(obj, subExpr, null, options);
+      }
+    } else {
+      dropKeys.push(key);
+      continue;
+    }
+    const objPathGraph = resolveGraph(obj, key, {
+      preserveMissing: true
+    });
+    if (objPathGraph !== void 0) {
+      merge(newObj, objPathGraph, {
+        flatten: true
+      });
+    }
+    if (notInArray([0, 1, false, true], subExpr)) {
+      if (value === void 0) {
+        removeValue(newObj, key, { descendArray: true });
+      } else {
+        setValue(newObj, key, value);
+      }
+    }
+  }
+  filterMissing(newObj);
+  if (foundSlice || foundExclusion || idOnlyExcluded) {
+    newObj = into({}, obj, newObj);
+    if (dropKeys.length > 0) {
+      for (const k of dropKeys) {
+        removeValue(newObj, k, { descendArray: true });
+      }
+    }
+  }
+  return newObj;
+}
+function validateExpression(expr, options) {
+  const check = [false, false];
+  for (const [k, v] of Object.entries(expr)) {
+    if (k === options?.idKey)
+      return;
+    if (v === 0 || v === false) {
+      check[0] = true;
+    } else if (v === 1 || v === true) {
+      check[1] = true;
+    }
+    assert(
+      !(check[0] && check[1]),
+      "Projection cannot have a mix of inclusion and exclusion."
+    );
+  }
+}
+export {
+  $project
+};

package/rust-client/node_modules/mingo/dist/esm/operators/pipeline/redact.js

@@ -0,0 +1,8 @@
+import { ComputeOptions, redact } from "../../core";
+const $redact = (collection, expr, options) => {
+  const copts = ComputeOptions.init(options);
+  return collection.map((obj) => redact(obj, expr, copts.update(obj)));
+};
+export {
+  $redact
+};

package/rust-client/node_modules/mingo/dist/esm/operators/pipeline/replaceRoot.js

@@ -0,0 +1,12 @@
+import { computeValue } from "../../core";
+import { assert, isObject } from "../../util";
+const $replaceRoot = (collection, expr, options) => {
+  return collection.map((obj) => {
+    obj = computeValue(obj, expr.newRoot, null, options);
+    assert(isObject(obj), "$replaceRoot expression must return an object");
+    return obj;
+  });
+};
+export {
+  $replaceRoot
+};

package/rust-client/node_modules/mingo/dist/esm/operators/pipeline/replaceWith.js

@@ -0,0 +1,5 @@
+import { $replaceRoot } from "./replaceRoot";
+const $replaceWith = $replaceRoot;
+export {
+  $replaceWith
+};

package/rust-client/node_modules/mingo/dist/esm/operators/pipeline/sample.js

@@ -0,0 +1,15 @@
+const $sample = (collection, expr, _options) => {
+  return collection.transform((xs) => {
+    const len = xs.length;
+    let i = -1;
+    return () => {
+      if (++i === expr.size)
+        return { done: true };
+      const n = Math.floor(Math.random() * len);
+      return { value: xs[n], done: false };
+    };
+  });
+};
+export {
+  $sample
+};

package/rust-client/node_modules/mingo/dist/esm/operators/pipeline/set.js

@@ -0,0 +1,5 @@
+import { $addFields } from "./addFields";
+const $set = $addFields;
+export {
+  $set
+};

package/rust-client/node_modules/mingo/dist/esm/operators/pipeline/setWindowFields.js

@@ -0,0 +1,202 @@
+import {
+  getOperator,
+  initOptions,
+  OperatorType
+} from "../../core";
+import { compose, Lazy } from "../../lazy";
+import { assert, isNumber, isOperator, isString } from "../../util";
+import { $function } from "../expression/custom/function";
+import { $dateAdd } from "../expression/date/dateAdd";
+import { isUnbounded } from "./_internal";
+import { $addFields } from "./addFields";
+import { $group } from "./group";
+import { $sort } from "./sort";
+const SORT_REQUIRED_OPS = /* @__PURE__ */ new Set([
+  "$denseRank",
+  "$documentNumber",
+  "$first",
+  "$last",
+  "$linearFill",
+  "$rank",
+  "$shift"
+]);
+const WINDOW_UNBOUNDED_OPS = /* @__PURE__ */ new Set([
+  "$denseRank",
+  "$expMovingAvg",
+  "$linearFill",
+  "$locf",
+  "$rank",
+  "$shift"
+]);
+const $setWindowFields = (collection, expr, options) => {
+  options = initOptions(options);
+  options.context.addExpressionOps({ $function });
+  for (const outputExpr of Object.values(expr.output)) {
+    const keys = Object.keys(outputExpr);
+    const op = keys.find(isOperator);
+    assert(
+      !!getOperator(OperatorType.WINDOW, op, options) || !!getOperator(OperatorType.ACCUMULATOR, op, options),
+      `'${op}' is not a valid window operator`
+    );
+    assert(
+      keys.length > 0 && keys.length <= 2 && (keys.length == 1 || keys.includes("window")),
+      "'output' option should have a single window operator."
+    );
+    if (outputExpr?.window) {
+      const { documents, range } = outputExpr.window;
+      assert(
+        !!documents && !range || !documents && !!range || !documents && !range,
+        "'window' option supports only one of 'documents' or 'range'."
+      );
+    }
+  }
+  if (expr.sortBy) {
+    collection = $sort(collection, expr.sortBy, options);
+  }
+  collection = $group(
+    collection,
+    {
+      _id: expr.partitionBy,
+      items: { $push: "$$CURRENT" }
+    },
+    options
+  );
+  return collection.transform((partitions) => {
+    const iterators = [];
+    const outputConfig = [];
+    for (const [field, outputExpr] of Object.entries(expr.output)) {
+      const op = Object.keys(outputExpr).find(isOperator);
+      const config = {
+        operatorName: op,
+        func: {
+          left: getOperator(
+            OperatorType.ACCUMULATOR,
+            op,
+            options
+          ),
+          right: getOperator(OperatorType.WINDOW, op, options)
+        },
+        args: outputExpr[op],
+        field,
+        window: outputExpr.window
+      };
+      assert(
+        !!expr.sortBy || !(SORT_REQUIRED_OPS.has(op) || !config.window),
+        `${SORT_REQUIRED_OPS.has(op) ? `'${op}'` : "bounded window operation"} requires a sortBy.`
+      );
+      assert(
+        !config.window || !WINDOW_UNBOUNDED_OPS.has(op),
+        `${op} does not accept a 'window' field.`
+      );
+      outputConfig.push(config);
+    }
+    partitions.forEach((group) => {
+      const items = group.items;
+      let iterator = Lazy(items);
+      const windowResultMap = {};
+      for (const config of outputConfig) {
+        const { func, args, field, window } = config;
+        const makeResultFunc = (getItemsFn) => {
+          let index = -1;
+          return (obj) => {
+            ++index;
+            if (func.left) {
+              return func.left(getItemsFn(obj, index), args, options);
+            } else if (func.right) {
+              return func.right(
+                obj,
+                getItemsFn(obj, index),
+                {
+                  parentExpr: expr,
+                  inputExpr: args,
+                  documentNumber: index + 1,
+                  field
+                },
+                // must use raw options only since it operates over a collection.
+                options
+              );
+            }
+          };
+        };
+        if (window) {
+          const { documents, range, unit } = window;
+          const boundary = documents || range;
+          if (!isUnbounded(window)) {
+            const [begin, end] = boundary;
+            const toBeginIndex = (currentIndex) => {
+              if (begin == "current")
+                return currentIndex;
+              if (begin == "unbounded")
+                return 0;
+              return Math.max(begin + currentIndex, 0);
+            };
+            const toEndIndex = (currentIndex) => {
+              if (end == "current")
+                return currentIndex + 1;
+              if (end == "unbounded")
+                return items.length;
+              return end + currentIndex + 1;
+            };
+            const getItems = (current, index) => {
+              if (!!documents || boundary.every(isString)) {
+                return items.slice(toBeginIndex(index), toEndIndex(index));
+              }
+              const sortKey = Object.keys(expr.sortBy)[0];
+              let lower;
+              let upper;
+              if (unit) {
+                const getTime = (amount) => {
+                  return $dateAdd(
+                    current,
+                    {
+                      startDate: new Date(current[sortKey]),
+                      unit,
+                      amount
+                    },
+                    options
+                  ).getTime();
+                };
+                lower = isNumber(begin) ? getTime(begin) : -Infinity;
+                upper = isNumber(end) ? getTime(end) : Infinity;
+              } else {
+                const currentValue = current[sortKey];
+                lower = isNumber(begin) ? currentValue + begin : -Infinity;
+                upper = isNumber(end) ? currentValue + end : Infinity;
+              }
+              let array = items;
+              if (begin == "current")
+                array = items.slice(index);
+              if (end == "current")
+                array = items.slice(0, index + 1);
+              return array.filter((o) => {
+                const n = +o[sortKey];
+                return n >= lower && n <= upper;
+              });
+            };
+            windowResultMap[field] = makeResultFunc(getItems);
+          }
+        }
+        if (!windowResultMap[field]) {
+          windowResultMap[field] = makeResultFunc((_) => items);
+        }
+        iterator = $addFields(
+          iterator,
+          {
+            [field]: {
+              $function: {
+                body: (obj) => windowResultMap[field](obj),
+                args: ["$$CURRENT"]
+              }
+            }
+          },
+          options
+        );
+      }
+      iterators.push(iterator);
+    });
+    return compose(...iterators);
+  });
+};
+export {
+  $setWindowFields
+};

package/rust-client/node_modules/mingo/dist/esm/operators/pipeline/skip.js

@@ -0,0 +1,6 @@
+const $skip = (collection, expr, options) => {
+  return collection.drop(expr);
+};
+export {
+  $skip
+};