@valkey/valkey-glide-darwin-arm64 1.3.2 → 1.3.4-rc0

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

@@ -1,183 +0,0 @@
-import { ComputeOptions } from "../../core";
-import { concat, Lazy } from "../../lazy";
-import { TIME_UNITS } from "../../types";
-import {
-  assert,
-  isArray,
-  isDate,
-  isNil,
-  isNumber,
-  isObject,
-  isString,
-  resolve,
-  ValueMap
-} from "../../util";
-import { $dateAdd } from "../expression/date/dateAdd";
-import { $sort } from "./sort";
-const EMPTY_OBJECT = Object.freeze({});
-const $densify = (collection, expr, options) => {
-  const { step, bounds, unit } = expr.range;
-  if (unit) {
-    assert(TIME_UNITS.includes(unit), "");
-    assert(
-      Number.isInteger(step) && step > 0,
-      "The step parameter in a range statement must be a whole number when densifying a date range."
-    );
-  } else {
-    assert(
-      isNumber(step) && step > 0,
-      "The step parameter in a range statement must be a strictly positive numeric value."
-    );
-  }
-  if (isArray(bounds)) {
-    assert(
-      !!bounds && bounds.length === 2,
-      "A bounding array in a range statement must have exactly two elements."
-    );
-    assert(
-      (bounds.every(isNumber) || bounds.every(isDate)) && bounds[0] < bounds[1],
-      "A bounding array must be an ascending array of either two dates or two numbers."
-    );
-    assert(
-      unit && !bounds.some(isNumber),
-      "Numeric bounds may not have unit parameter."
-    );
-  }
-  if (expr.partitionByFields) {
-    assert(
-      isArray(expr.partitionByFields),
-      "$densify: `partitionByFields` must be an array of strings"
-    );
-  }
-  collection = $sort(collection, { [expr.field]: 1 }, options);
-  const nilOptions = ComputeOptions.init(options, null);
-  const computeNextValue = (value) => {
-    return isNumber(value) ? value + step : $dateAdd(
-      EMPTY_OBJECT,
-      { startDate: value, unit, amount: step },
-      nilOptions
-    );
-  };
-  const isValidUnit = !!unit && TIME_UNITS.includes(unit);
-  const getFieldValue = (o) => {
-    const v = resolve(o, expr.field);
-    if (isNil(v)) return v;
-    if (isNumber(v)) {
-      assert(
-        !isValidUnit,
-        "$densify: Encountered non-date value in collection when step has a date unit."
-      );
-    } else if (isDate(v)) {
-      assert(
-        isValidUnit,
-        "$densify: Encountered date value in collection when step does not have a date unit."
-      );
-    } else {
-      assert(false, "$densify: Densify field type must be numeric or a date");
-    }
-    return v;
-  };
-  const peekItem = new Array();
-  const nilFieldsIterator = Lazy(() => {
-    const item = collection.next();
-    const fieldValue = getFieldValue(item.value);
-    if (isNil(fieldValue)) return item;
-    peekItem.push(item);
-    return { done: true };
-  });
-  const nextDensifyValueMap = ValueMap.init(
-    options.hashFunction
-  );
-  const [lower, upper] = isArray(bounds) ? bounds : [bounds, bounds];
-  let maxFieldValue = void 0;
-  const updateMaxFieldValue = (value) => {
-    maxFieldValue = maxFieldValue === void 0 || maxFieldValue < value ? value : maxFieldValue;
-  };
-  const rootKey = [];
-  const densifyIterator = Lazy(() => {
-    const item = peekItem.length > 0 ? peekItem.pop() : collection.next();
-    if (item.done) return item;
-    let partitionKey = rootKey;
-    if (isArray(expr.partitionByFields)) {
-      partitionKey = expr.partitionByFields.map(
-        (k) => resolve(item.value, k)
-      );
-      assert(
-        partitionKey.every(isString),
-        "$densify: Partition fields must evaluate to string values."
-      );
-    }
-    assert(isObject(item.value), "$densify: collection must contain documents");
-    const itemValue = getFieldValue(item.value);
-    if (!nextDensifyValueMap.has(partitionKey)) {
-      if (lower == "full") {
-        if (!nextDensifyValueMap.has(rootKey)) {
-          nextDensifyValueMap.set(rootKey, itemValue);
-        }
-        nextDensifyValueMap.set(partitionKey, nextDensifyValueMap.get(rootKey));
-      } else if (lower == "partition") {
-        nextDensifyValueMap.set(partitionKey, itemValue);
-      } else {
-        nextDensifyValueMap.set(partitionKey, lower);
-      }
-    }
-    const densifyValue = nextDensifyValueMap.get(partitionKey);
-    if (
-      // current item field value is lower than current densify value.
-      itemValue <= densifyValue || // range value equals or exceeds upper bound
-      upper != "full" && upper != "partition" && densifyValue >= upper
-    ) {
-      if (densifyValue <= itemValue) {
-        nextDensifyValueMap.set(partitionKey, computeNextValue(densifyValue));
-      }
-      updateMaxFieldValue(itemValue);
-      return item;
-    }
-    nextDensifyValueMap.set(partitionKey, computeNextValue(densifyValue));
-    updateMaxFieldValue(densifyValue);
-    const denseObj = { [expr.field]: densifyValue };
-    if (partitionKey) {
-      partitionKey.forEach((v, i) => {
-        denseObj[expr.partitionByFields[i]] = v;
-      });
-    }
-    peekItem.push(item);
-    return { done: false, value: denseObj };
-  });
-  if (lower !== "full") return concat(nilFieldsIterator, densifyIterator);
-  let paritionIndex = -1;
-  let partitionKeysSet = void 0;
-  const fullBoundsIterator = Lazy(() => {
-    if (paritionIndex === -1) {
-      const fullDensifyValue = nextDensifyValueMap.get(rootKey);
-      nextDensifyValueMap.delete(rootKey);
-      partitionKeysSet = Array.from(nextDensifyValueMap.keys());
-      if (partitionKeysSet.length === 0) {
-        partitionKeysSet.push(rootKey);
-        nextDensifyValueMap.set(rootKey, fullDensifyValue);
-      }
-      paritionIndex++;
-    }
-    do {
-      const partitionKey = partitionKeysSet[paritionIndex];
-      const partitionMaxValue = nextDensifyValueMap.get(partitionKey);
-      if (partitionMaxValue < maxFieldValue) {
-        nextDensifyValueMap.set(
-          partitionKey,
-          computeNextValue(partitionMaxValue)
-        );
-        const denseObj = { [expr.field]: partitionMaxValue };
-        partitionKey.forEach((v, i) => {
-          denseObj[expr.partitionByFields[i]] = v;
-        });
-        return { done: false, value: denseObj };
-      }
-      paritionIndex++;
-    } while (paritionIndex < partitionKeysSet.length);
-    return { done: true };
-  });
-  return concat(nilFieldsIterator, densifyIterator, fullBoundsIterator);
-};
-export {
-  $densify
-};

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

@@ -1,17 +0,0 @@
-import { Aggregator } from "../../aggregator";
-import { ProcessingMode } from "../../core";
-const $facet = (collection, expr, options) => {
-  return collection.transform((array) => {
-    const o = {};
-    for (const [k, pipeline] of Object.entries(expr)) {
-      o[k] = new Aggregator(pipeline, {
-        ...options,
-        processingMode: ProcessingMode.CLONE_INPUT
-      }).run(array);
-    }
-    return [o];
-  });
-};
-export {
-  $facet
-};

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

@@ -1,59 +0,0 @@
-import { initOptions } from "../../core";
-import { assert, has, isObject } from "../../util";
-import { $ifNull } from "../expression/conditional/ifNull";
-import { $linearFill } from "../window/linearFill";
-import { $locf } from "../window/locf";
-import { $addFields } from "./addFields";
-import { $setWindowFields } from "./setWindowFields";
-const FILL_METHODS = {
-  locf: "$locf",
-  linear: "$linearFill"
-};
-const $fill = (collection, expr, options) => {
-  assert(!expr.sortBy || isObject(expr.sortBy), "sortBy must be an object.");
-  assert(
-    !!expr.sortBy || Object.values(expr.output).every((m) => has(m, "value")),
-    "sortBy required if any output field specifies a 'method'."
-  );
-  assert(
-    !(expr.partitionBy && expr.partitionByFields),
-    "specify either partitionBy or partitionByFields."
-  );
-  assert(
-    !expr.partitionByFields || expr?.partitionByFields?.every((s) => s[0] !== "$"),
-    "fields in partitionByFields cannot begin with '$'."
-  );
-  options = initOptions(options);
-  options.context.addExpressionOps({ $ifNull });
-  options.context.addWindowOps({ $locf, $linearFill });
-  const partitionExpr = expr.partitionBy || expr?.partitionByFields?.map((s) => "$" + s);
-  const valueExpr = {};
-  const methodExpr = {};
-  for (const [k, m] of Object.entries(expr.output)) {
-    if (has(m, "value")) {
-      valueExpr[k] = { $ifNull: [`$$CURRENT.${k}`, m["value"]] };
-    } else {
-      const fillOp = FILL_METHODS[m["method"]];
-      assert(!!fillOp, `invalid fill method '${m["method"]}'.`);
-      methodExpr[k] = { [fillOp]: "$" + k };
-    }
-  }
-  if (Object.keys(methodExpr).length > 0) {
-    collection = $setWindowFields(
-      collection,
-      {
-        sortBy: expr.sortBy || {},
-        partitionBy: partitionExpr,
-        output: methodExpr
-      },
-      options
-    );
-  }
-  if (Object.keys(valueExpr).length > 0) {
-    collection = $addFields(collection, valueExpr, options);
-  }
-  return collection;
-};
-export {
-  $fill
-};

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

@@ -1,55 +0,0 @@
-import { computeValue } from "../../core";
-import { Lazy } from "../../lazy";
-import { flatten, isNil, isString, setValue, ValueMap } from "../../util";
-import { $lookup } from "./lookup";
-const $graphLookup = (collection, expr, options) => {
-  const fromColl = isString(expr.from) ? options?.collectionResolver(expr.from) : expr.from;
-  const {
-    connectFromField,
-    connectToField,
-    as: asField,
-    maxDepth,
-    depthField,
-    restrictSearchWithMatch: matchExpr
-  } = expr;
-  const pipelineExpr = matchExpr ? { pipeline: [{ $match: matchExpr }] } : {};
-  return collection.map((obj) => {
-    const matchObj = {};
-    setValue(
-      matchObj,
-      connectFromField,
-      computeValue(obj, expr.startWith, null, options)
-    );
-    let matches = [matchObj];
-    let i = -1;
-    const map = ValueMap.init(options.hashFunction);
-    do {
-      i++;
-      matches = flatten(
-        $lookup(
-          Lazy(matches),
-          {
-            from: fromColl,
-            localField: connectFromField,
-            foreignField: connectToField,
-            as: asField,
-            ...pipelineExpr
-          },
-          options
-        ).map((o) => o[asField]).value()
-      );
-      const oldSize = map.size;
-      matches.forEach((k) => map.set(k, map.get(k) ?? i));
-      if (oldSize == map.size) break;
-    } while (isNil(maxDepth) || i < maxDepth);
-    const result = new Array(map.size);
-    let n = 0;
-    map.forEach((v, k) => {
-      result[n++] = Object.assign(depthField ? { [depthField]: v } : {}, k);
-    });
-    return { ...obj, [asField]: result };
-  });
-};
-export {
-  $graphLookup
-};

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

@@ -1,41 +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), "$group specification must include an '_id'");
-  const idExpr = expr[ID_KEY];
-  const copts = ComputeOptions.init(options);
-  const newFields = Object.keys(expr).filter((k) => k != ID_KEY);
-  return collection.transform((coll) => {
-    const partitions = groupBy(
-      coll,
-      (obj) => computeValue(obj, idExpr, null, options),
-      options.hashFunction
-    );
-    let i = -1;
-    const partitionKeys = Array.from(partitions.keys());
-    return () => {
-      if (++i === partitions.size) return { done: true };
-      const groupId = partitionKeys[i];
-      const obj = {};
-      if (groupId !== void 0) {
-        obj[ID_KEY] = groupId;
-      }
-      for (const key of newFields) {
-        obj[key] = computeValue(
-          partitions.get(groupId),
-          expr[key],
-          null,
-          copts.update(null, { groupId })
-        );
-      }
-      return { value: obj, done: false };
-    };
-  });
-};
-export {
-  $group
-};

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

@@ -1,27 +0,0 @@
-export * from "./addFields";
-export * from "./bucket";
-export * from "./bucketAuto";
-export * from "./count";
-export * from "./densify";
-export * from "./facet";
-export * from "./fill";
-export * from "./graphLookup";
-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,4 +0,0 @@
-const $limit = (collection, expr, _options) => collection.take(expr);
-export {
-  $limit
-};

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

@@ -1,63 +0,0 @@
-import { Aggregator } from "../../aggregator";
-import { computeValue } from "../../core";
-import {
-  ensureArray,
-  flatten,
-  isArray,
-  isString,
-  resolve,
-  ValueMap
-} from "../../util";
-const $lookup = (collection, expr, options) => {
-  const joinColl = isString(expr.from) ? options?.collectionResolver(expr.from) : expr.from;
-  const { let: letExpr, pipeline, foreignField, localField } = expr;
-  const subQueryPipeline = pipeline || [];
-  let lookupEq = (_) => [true, []];
-  if (foreignField && localField) {
-    const map = ValueMap.init(options.hashFunction);
-    for (const doc of joinColl) {
-      ensureArray(resolve(doc, foreignField) ?? null).forEach((v) => {
-        const xs = map.get(v);
-        const arr = xs ?? [];
-        arr.push(doc);
-        if (arr !== xs) map.set(v, arr);
-      });
-    }
-    lookupEq = (o) => {
-      const local = resolve(o, localField) ?? null;
-      if (isArray(local)) {
-        if (subQueryPipeline.length) {
-          return [local.some((v) => map.has(v)), null];
-        }
-        const result2 = Array.from(
-          new Set(flatten(local.map((v) => map.get(v), options.hashFunction)))
-        );
-        return [result2.length > 0, result2];
-      }
-      const result = map.get(local) ?? null;
-      return [result !== null, result ?? []];
-    };
-    if (subQueryPipeline.length === 0) {
-      return collection.map((obj) => {
-        return {
-          ...obj,
-          [expr.as]: lookupEq(obj).pop()
-        };
-      });
-    }
-  }
-  const agg = new Aggregator(subQueryPipeline, options);
-  const opts = { ...options };
-  return collection.map((obj) => {
-    const vars = computeValue(obj, letExpr, null, options);
-    opts.variables = { ...options.variables, ...vars };
-    const [ok, res] = lookupEq(obj);
-    return {
-      ...obj,
-      [expr.as]: ok ? agg.run(joinColl, opts) : res
-    };
-  });
-};
-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,90 +0,0 @@
-import { Aggregator } from "../../aggregator";
-import {
-  ComputeOptions,
-  computeValue
-} from "../../core";
-import {
-  assert,
-  hashCode,
-  isArray,
-  isString,
-  MingoError,
-  resolve,
-  ValueMap
-} from "../../util";
-import { $mergeObjects } from "../expression";
-const $merge = (collection, expr, options) => {
-  const output = isString(expr.into) ? options?.collectionResolver(expr.into) : expr.into;
-  assert(isArray(output), `$merge: option 'into' must resolve to an array`);
-  const onField = expr.on || options.idKey;
-  const getHash = isString(onField) ? (o) => hashCode(resolve(o, onField), options.hashFunction) : (o) => hashCode(onField.map((s) => resolve(o, s), options.hashFunction));
-  const map = ValueMap.init();
-  for (let i = 0; i < output.length; i++) {
-    const obj = output[i];
-    const k = getHash(obj);
-    assert(
-      !map.has(k),
-      "$merge: 'into' collection must have unique entries for the 'on' field."
-    );
-    map.set(k, [obj, i]);
-  }
-  const copts = ComputeOptions.init(options);
-  return collection.map((o) => {
-    const k = getHash(o);
-    if (map.has(k)) {
-      const [target, i] = map.get(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, isArray, isString } from "../../util";
-const $out = (collection, expr, options) => {
-  const outputColl = isString(expr) ? options?.collectionResolver(expr) : expr;
-  assert(isArray(outputColl), `expression must resolve to an array`);
-  return collection.map((o) => {
-    outputColl.push(cloneDeep(o));
-    return o;
-  });
-};
-export {
-  $out
-};