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

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

@@ -1,8 +1,8 @@
 import { Lazy } from "../../lazy";
-import { assert, isString } from "../../util";
-const $count = (collection, expr, _) => {
+import { assert, isEmpty, isString } from "../../util";
+const $count = (collection, expr, _options) => {
   assert(
-    isString(expr) && expr.trim() !== "" && expr.indexOf(".") === -1 && expr.trim()[0] !== "$",
+    isString(expr) && !isEmpty(expr) && expr.indexOf(".") === -1 && expr.trim()[0] !== "$",
     "Invalid expression value for $count"
   );
   return Lazy([

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

@@ -0,0 +1,183 @@
+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/graphLookup.js

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

@@ -5,33 +5,30 @@ import {
 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");
+  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
     );
-    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 };
+      if (++i === partitions.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)) {
+      for (const key of newFields) {
         obj[key] = computeValue(
           partitions.get(groupId),
-          val,
-          key,
+          expr[key],
+          null,
           copts.update(null, { groupId })
         );
       }

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

@@ -2,8 +2,10 @@ 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";

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

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

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

@@ -1,18 +1,62 @@
-import { assert, hashCode, into, isString, resolve } from "../../util";
+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;
-  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);
+  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);
   return collection.map((obj) => {
-    const k = hashCode(resolve(obj, expr.localField), options?.hashFunction);
-    const newObj = into({}, obj);
-    newObj[expr.as] = hash[k] || [];
-    return newObj;
+    const variables = computeValue(obj, letExpr, null, options);
+    const opts = Object.assign({}, options, {
+      variables: { ...options.variables, ...variables }
+    });
+    const [ok, res] = lookupEq(obj);
+    return {
+      ...obj,
+      [expr.as]: ok ? agg.run(joinColl, opts) : res
+    };
   });
 };
 export {

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

@@ -9,35 +9,30 @@ import {
   isArray,
   isString,
   MingoError,
-  resolve
+  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(
-    output instanceof Array,
-    `$merge: option 'into' must resolve to an array`
-  );
+  assert(isArray(output), `$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 = {};
+  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(
-      !hash[k],
+      !map.has(k),
       "$merge: 'into' collection must have unique entries for the 'on' field."
     );
-    hash[k] = [obj, i];
+    map.set(k, [obj, i]);
   }
   const copts = ComputeOptions.init(options);
   return collection.map((o) => {
     const k = getHash(o);
-    if (hash[k]) {
-      const [target, i] = hash[k];
+    if (map.has(k)) {
+      const [target, i] = map.get(k);
       const variables = computeValue(
         target,
         expr.let || { new: "$$ROOT" },

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

@@ -1,7 +1,7 @@
-import { assert, cloneDeep, isString } from "../../util";
+import { assert, cloneDeep, isArray, 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`);
+  assert(isArray(outputColl), `expression must resolve to an array`);
   return collection.map((o) => {
     outputColl.push(cloneDeep(o));
     return o;

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

@@ -1,16 +1,15 @@
 import {
   ComputeOptions,
   computeValue,
-  getOperator,
-  OperatorType
+  getOperator
 } from "../../core";
 import {
   assert,
   ensureArray,
   filterMissing,
   has,
-  inArray,
   into,
+  isArray,
   isEmpty,
   isNil,
   isNumber,
@@ -18,42 +17,27 @@ import {
   isOperator,
   isString,
   merge,
-  notInArray,
   removeValue,
   resolveGraph,
   setValue
 } from "../../util";
+const DESCRIPTORS = new Set(Array.from([0, 1, false, true]));
 const $project = (collection, expr, options) => {
-  if (isEmpty(expr))
-    return collection;
-  let expressionKeys = Object.keys(expr);
-  let idOnlyExcluded = false;
+  if (isEmpty(expr)) return collection;
+  const expressionKeys = Object.keys(expr);
   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 {
+  if (!expressionKeys.includes(ID_KEY)) {
     expressionKeys.push(ID_KEY);
   }
   const copts = ComputeOptions.init(options);
-  return collection.map((obj) => processObject(
-    obj,
-    expr,
-    copts.update(obj),
-    expressionKeys,
-    idOnlyExcluded
-  ));
+  return collection.map((obj) => processObject(obj, expr, copts.update(obj), expressionKeys));
 };
-function processObject(obj, expr, options, expressionKeys, idOnlyExcluded) {
+function processObject(obj, expr, options, expressionKeys) {
   let newObj = {};
   let foundSlice = false;
   let foundExclusion = false;
+  const idOnlyExcluded = expr[options.idKey] === 0 && expressionKeys.length === 1;
   const dropKeys = [];
   if (idOnlyExcluded) {
     dropKeys.push(options.idKey);
@@ -61,19 +45,18 @@ function processObject(obj, expr, options, expressionKeys, idOnlyExcluded) {
   for (const key of expressionKeys) {
     let value = void 0;
     const subExpr = expr[key];
-    if (key !== options.idKey && inArray([0, false], subExpr)) {
+    if (key !== options.idKey && (subExpr === 0 || subExpr === false)) {
       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) {
+    } else if (subExpr === 1 || subExpr === true) {
+    } else if (isArray(subExpr)) {
       value = subExpr.map((v) => {
         const r = computeValue(obj, v, null, options);
-        if (isNil(r))
-          return null;
+        if (isNil(r)) return null;
         return r;
       });
     } else if (isObject(subExpr)) {
@@ -81,7 +64,7 @@ function processObject(obj, expr, options, expressionKeys, idOnlyExcluded) {
       const subExprKeys = Object.keys(subExpr);
       const operator = subExprKeys.length == 1 ? subExprKeys[0] : "";
       const call = getOperator(
-        OperatorType.PROJECTION,
+        "projection",
         operator,
         options
       );
@@ -101,9 +84,9 @@ function processObject(obj, expr, options, expressionKeys, idOnlyExcluded) {
       } else if (has(obj, key)) {
         validateExpression(subExprObj, options);
         let target = obj[key];
-        if (target instanceof Array) {
+        if (isArray(target)) {
           value = target.map(
-            (o) => processObject(o, subExprObj, options, subExprKeys, false)
+            (o) => processObject(o, subExprObj, options, subExprKeys)
           );
         } else {
           target = isObject(target) ? target : obj;
@@ -111,8 +94,7 @@ function processObject(obj, expr, options, expressionKeys, idOnlyExcluded) {
             target,
             subExprObj,
             options,
-            subExprKeys,
-            false
+            subExprKeys
           );
         }
       } else {
@@ -125,12 +107,10 @@ function processObject(obj, expr, options, expressionKeys, idOnlyExcluded) {
     const objPathGraph = resolveGraph(obj, key, {
       preserveMissing: true
     });
-    if (objPathGraph !== void 0) {
-      merge(newObj, objPathGraph, {
-        flatten: true
-      });
+    if (isObject(objPathGraph)) {
+      merge(newObj, objPathGraph);
     }
-    if (notInArray([0, 1, false, true], subExpr)) {
+    if (!DESCRIPTORS.has(subExpr)) {
       if (value === void 0) {
         removeValue(newObj, key, { descendArray: true });
       } else {
@@ -152,8 +132,7 @@ function processObject(obj, expr, options, expressionKeys, idOnlyExcluded) {
 function validateExpression(expr, options) {
   const check = [false, false];
   for (const [k, v] of Object.entries(expr)) {
-    if (k === options?.idKey)
-      return;
+    if (k === options?.idKey) return;
     if (v === 0 || v === false) {
       check[0] = true;
     } else if (v === 1 || v === true) {

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

@@ -1,7 +1,9 @@
 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)));
+  return collection.map(
+    (obj) => redact(obj, expr, copts.update(obj))
+  );
 };
 export {
   $redact

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

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

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

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