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

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

@@ -1,44 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

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

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

@@ -1,20 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,95 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,170 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

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

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

@@ -1,15 +0,0 @@
-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

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

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

@@ -1,202 +0,0 @@
-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

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