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

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

@@ -22,9 +22,9 @@ __export(count_exports, {
 module.exports = __toCommonJS(count_exports);
 var import_lazy = require("../../lazy");
 var import_util = require("../../util");
-const $count = (collection, expr, _) => {
+const $count = (collection, expr, _options) => {
   (0, import_util.assert)(
-    (0, import_util.isString)(expr) && expr.trim() !== "" && expr.indexOf(".") === -1 && expr.trim()[0] !== "$",
+    (0, import_util.isString)(expr) && !(0, import_util.isEmpty)(expr) && expr.indexOf(".") === -1 && expr.trim()[0] !== "$",
     "Invalid expression value for $count"
   );
   return (0, import_lazy.Lazy)([

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

@@ -0,0 +1,196 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var densify_exports = {};
+__export(densify_exports, {
+  $densify: () => $densify
+});
+module.exports = __toCommonJS(densify_exports);
+var import_core = require("../../core");
+var import_lazy = require("../../lazy");
+var import_types = require("../../types");
+var import_util = require("../../util");
+var import_dateAdd = require("../expression/date/dateAdd");
+var import_sort = require("./sort");
+const EMPTY_OBJECT = Object.freeze({});
+const $densify = (collection, expr, options) => {
+  const { step, bounds, unit } = expr.range;
+  if (unit) {
+    (0, import_util.assert)(import_types.TIME_UNITS.includes(unit), "");
+    (0, import_util.assert)(
+      Number.isInteger(step) && step > 0,
+      "The step parameter in a range statement must be a whole number when densifying a date range."
+    );
+  } else {
+    (0, import_util.assert)(
+      (0, import_util.isNumber)(step) && step > 0,
+      "The step parameter in a range statement must be a strictly positive numeric value."
+    );
+  }
+  if ((0, import_util.isArray)(bounds)) {
+    (0, import_util.assert)(
+      !!bounds && bounds.length === 2,
+      "A bounding array in a range statement must have exactly two elements."
+    );
+    (0, import_util.assert)(
+      (bounds.every(import_util.isNumber) || bounds.every(import_util.isDate)) && bounds[0] < bounds[1],
+      "A bounding array must be an ascending array of either two dates or two numbers."
+    );
+    (0, import_util.assert)(
+      unit && !bounds.some(import_util.isNumber),
+      "Numeric bounds may not have unit parameter."
+    );
+  }
+  if (expr.partitionByFields) {
+    (0, import_util.assert)(
+      (0, import_util.isArray)(expr.partitionByFields),
+      "$densify: `partitionByFields` must be an array of strings"
+    );
+  }
+  collection = (0, import_sort.$sort)(collection, { [expr.field]: 1 }, options);
+  const nilOptions = import_core.ComputeOptions.init(options, null);
+  const computeNextValue = (value) => {
+    return (0, import_util.isNumber)(value) ? value + step : (0, import_dateAdd.$dateAdd)(
+      EMPTY_OBJECT,
+      { startDate: value, unit, amount: step },
+      nilOptions
+    );
+  };
+  const isValidUnit = !!unit && import_types.TIME_UNITS.includes(unit);
+  const getFieldValue = (o) => {
+    const v = (0, import_util.resolve)(o, expr.field);
+    if ((0, import_util.isNil)(v)) return v;
+    if ((0, import_util.isNumber)(v)) {
+      (0, import_util.assert)(
+        !isValidUnit,
+        "$densify: Encountered non-date value in collection when step has a date unit."
+      );
+    } else if ((0, import_util.isDate)(v)) {
+      (0, import_util.assert)(
+        isValidUnit,
+        "$densify: Encountered date value in collection when step does not have a date unit."
+      );
+    } else {
+      (0, import_util.assert)(false, "$densify: Densify field type must be numeric or a date");
+    }
+    return v;
+  };
+  const peekItem = new Array();
+  const nilFieldsIterator = (0, import_lazy.Lazy)(() => {
+    const item = collection.next();
+    const fieldValue = getFieldValue(item.value);
+    if ((0, import_util.isNil)(fieldValue)) return item;
+    peekItem.push(item);
+    return { done: true };
+  });
+  const nextDensifyValueMap = import_util.ValueMap.init(
+    options.hashFunction
+  );
+  const [lower, upper] = (0, import_util.isArray)(bounds) ? bounds : [bounds, bounds];
+  let maxFieldValue = void 0;
+  const updateMaxFieldValue = (value) => {
+    maxFieldValue = maxFieldValue === void 0 || maxFieldValue < value ? value : maxFieldValue;
+  };
+  const rootKey = [];
+  const densifyIterator = (0, import_lazy.Lazy)(() => {
+    const item = peekItem.length > 0 ? peekItem.pop() : collection.next();
+    if (item.done) return item;
+    let partitionKey = rootKey;
+    if ((0, import_util.isArray)(expr.partitionByFields)) {
+      partitionKey = expr.partitionByFields.map(
+        (k) => (0, import_util.resolve)(item.value, k)
+      );
+      (0, import_util.assert)(
+        partitionKey.every(import_util.isString),
+        "$densify: Partition fields must evaluate to string values."
+      );
+    }
+    (0, import_util.assert)((0, import_util.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 (0, import_lazy.concat)(nilFieldsIterator, densifyIterator);
+  let paritionIndex = -1;
+  let partitionKeysSet = void 0;
+  const fullBoundsIterator = (0, import_lazy.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 (0, import_lazy.concat)(nilFieldsIterator, densifyIterator, fullBoundsIterator);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $densify
+});

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

@@ -0,0 +1,78 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var graphLookup_exports = {};
+__export(graphLookup_exports, {
+  $graphLookup: () => $graphLookup
+});
+module.exports = __toCommonJS(graphLookup_exports);
+var import_core = require("../../core");
+var import_lazy = require("../../lazy");
+var import_util = require("../../util");
+var import_lookup = require("./lookup");
+const $graphLookup = (collection, expr, options) => {
+  const fromColl = (0, import_util.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 = {};
+    (0, import_util.setValue)(
+      matchObj,
+      connectFromField,
+      (0, import_core.computeValue)(obj, expr.startWith, null, options)
+    );
+    let matches = [matchObj];
+    let i = -1;
+    const map = import_util.ValueMap.init(options.hashFunction);
+    do {
+      i++;
+      matches = (0, import_util.flatten)(
+        (0, import_lookup.$lookup)(
+          (0, import_lazy.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 ((0, import_util.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 };
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $graphLookup
+});

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

@@ -24,33 +24,30 @@ var import_core = require("../../core");
 var import_util = require("../../util");
 const ID_KEY = "_id";
 const $group = (collection, expr, options) => {
-  (0, import_util.assert)((0, import_util.has)(expr, ID_KEY), "a group specification must include an _id");
+  (0, import_util.assert)((0, import_util.has)(expr, ID_KEY), "$group specification must include an '_id'");
   const idExpr = expr[ID_KEY];
   const copts = import_core.ComputeOptions.init(options);
+  const newFields = Object.keys(expr).filter((k) => k != ID_KEY);
   return collection.transform((coll) => {
     const partitions = (0, import_util.groupBy)(
       coll,
       (obj) => (0, import_core.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] = (0, import_core.computeValue)(
           partitions.get(groupId),
-          val,
-          key,
+          expr[key],
+          null,
           copts.update(null, { groupId })
         );
       }

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

@@ -18,8 +18,10 @@ __reExport(pipeline_exports, require("./addFields"), module.exports);
 __reExport(pipeline_exports, require("./bucket"), module.exports);
 __reExport(pipeline_exports, require("./bucketAuto"), module.exports);
 __reExport(pipeline_exports, require("./count"), module.exports);
+__reExport(pipeline_exports, require("./densify"), module.exports);
 __reExport(pipeline_exports, require("./facet"), module.exports);
 __reExport(pipeline_exports, require("./fill"), module.exports);
+__reExport(pipeline_exports, require("./graphLookup"), module.exports);
 __reExport(pipeline_exports, require("./group"), module.exports);
 __reExport(pipeline_exports, require("./limit"), module.exports);
 __reExport(pipeline_exports, require("./lookup"), module.exports);
@@ -45,8 +47,10 @@ __reExport(pipeline_exports, require("./unwind"), module.exports);
   ...require("./bucket"),
   ...require("./bucketAuto"),
   ...require("./count"),
+  ...require("./densify"),
   ...require("./facet"),
   ...require("./fill"),
+  ...require("./graphLookup"),
   ...require("./group"),
   ...require("./limit"),
   ...require("./lookup"),

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

@@ -20,9 +20,7 @@ __export(limit_exports, {
   $limit: () => $limit
 });
 module.exports = __toCommonJS(limit_exports);
-const $limit = (collection, expr, options) => {
-  return collection.take(expr);
-};
+const $limit = (collection, expr, _options) => collection.take(expr);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   $limit

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

@@ -20,21 +20,58 @@ __export(lookup_exports, {
   $lookup: () => $lookup
 });
 module.exports = __toCommonJS(lookup_exports);
+var import_aggregator = require("../../aggregator");
+var import_core = require("../../core");
 var import_util = require("../../util");
 const $lookup = (collection, expr, options) => {
   const joinColl = (0, import_util.isString)(expr.from) ? options?.collectionResolver(expr.from) : expr.from;
-  (0, import_util.assert)(joinColl instanceof Array, `'from' field must resolve to an array`);
-  const hash = {};
-  for (const obj of joinColl) {
-    const k = (0, import_util.hashCode)((0, import_util.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 = import_util.ValueMap.init(options.hashFunction);
+    for (const doc of joinColl) {
+      (0, import_util.ensureArray)((0, import_util.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 = (0, import_util.resolve)(o, localField) ?? null;
+      if ((0, import_util.isArray)(local)) {
+        if (subQueryPipeline.length) {
+          return [local.some((v) => map.has(v)), null];
+        }
+        const result2 = Array.from(
+          new Set((0, import_util.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 import_aggregator.Aggregator(subQueryPipeline, options);
   return collection.map((obj) => {
-    const k = (0, import_util.hashCode)((0, import_util.resolve)(obj, expr.localField), options?.hashFunction);
-    const newObj = (0, import_util.into)({}, obj);
-    newObj[expr.as] = hash[k] || [];
-    return newObj;
+    const variables = (0, import_core.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
+    };
   });
 };
 // Annotate the CommonJS export names for ESM import in node:

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

@@ -26,30 +26,24 @@ var import_util = require("../../util");
 var import_expression = require("../expression");
 const $merge = (collection, expr, options) => {
   const output = (0, import_util.isString)(expr.into) ? options?.collectionResolver(expr.into) : expr.into;
-  (0, import_util.assert)(
-    output instanceof Array,
-    `$merge: option 'into' must resolve to an array`
-  );
+  (0, import_util.assert)((0, import_util.isArray)(output), `$merge: option 'into' must resolve to an array`);
   const onField = expr.on || options.idKey;
-  const getHash = (o) => {
-    const val = (0, import_util.isString)(onField) ? (0, import_util.resolve)(o, onField) : onField.map((s) => (0, import_util.resolve)(o, s));
-    return (0, import_util.hashCode)(val, options.hashFunction);
-  };
-  const hash = {};
+  const getHash = (0, import_util.isString)(onField) ? (o) => (0, import_util.hashCode)((0, import_util.resolve)(o, onField), options.hashFunction) : (o) => (0, import_util.hashCode)(onField.map((s) => (0, import_util.resolve)(o, s), options.hashFunction));
+  const map = import_util.ValueMap.init();
   for (let i = 0; i < output.length; i++) {
     const obj = output[i];
     const k = getHash(obj);
     (0, import_util.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 = import_core.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 = (0, import_core.computeValue)(
         target,
         expr.let || { new: "$$ROOT" },

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

@@ -23,7 +23,7 @@ module.exports = __toCommonJS(out_exports);
 var import_util = require("../../util");
 const $out = (collection, expr, options) => {
   const outputColl = (0, import_util.isString)(expr) ? options?.collectionResolver(expr) : expr;
-  (0, import_util.assert)(outputColl instanceof Array, `expression must resolve to an array`);
+  (0, import_util.assert)((0, import_util.isArray)(outputColl), `expression must resolve to an array`);
   return collection.map((o) => {
     outputColl.push((0, import_util.cloneDeep)(o));
     return o;

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

@@ -22,37 +22,23 @@ __export(project_exports, {
 module.exports = __toCommonJS(project_exports);
 var import_core = require("../../core");
 var import_util = require("../../util");
+const DESCRIPTORS = new Set(Array.from([0, 1, false, true]));
 const $project = (collection, expr, options) => {
-  if ((0, import_util.isEmpty)(expr))
-    return collection;
-  let expressionKeys = Object.keys(expr);
-  let idOnlyExcluded = false;
+  if ((0, import_util.isEmpty)(expr)) return collection;
+  const expressionKeys = Object.keys(expr);
   validateExpression(expr, options);
   const ID_KEY = options.idKey;
-  if ((0, import_util.inArray)(expressionKeys, ID_KEY)) {
-    const id = expr[ID_KEY];
-    if (id === 0 || id === false) {
-      expressionKeys = expressionKeys.filter(
-        import_util.notInArray.bind(null, [ID_KEY])
-      );
-      idOnlyExcluded = expressionKeys.length == 0;
-    }
-  } else {
+  if (!expressionKeys.includes(ID_KEY)) {
     expressionKeys.push(ID_KEY);
   }
   const copts = import_core.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);
@@ -60,19 +46,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 && (0, import_util.inArray)([0, false], subExpr)) {
+    if (key !== options.idKey && (subExpr === 0 || subExpr === false)) {
       foundExclusion = true;
     }
     if (key === options.idKey && (0, import_util.isEmpty)(subExpr)) {
       value = obj[key];
     } else if ((0, import_util.isString)(subExpr)) {
       value = (0, import_core.computeValue)(obj, subExpr, key, options);
-    } else if ((0, import_util.inArray)([1, true], subExpr)) {
-    } else if (subExpr instanceof Array) {
+    } else if (subExpr === 1 || subExpr === true) {
+    } else if ((0, import_util.isArray)(subExpr)) {
       value = subExpr.map((v) => {
         const r = (0, import_core.computeValue)(obj, v, null, options);
-        if ((0, import_util.isNil)(r))
-          return null;
+        if ((0, import_util.isNil)(r)) return null;
         return r;
       });
     } else if ((0, import_util.isObject)(subExpr)) {
@@ -80,7 +65,7 @@ function processObject(obj, expr, options, expressionKeys, idOnlyExcluded) {
       const subExprKeys = Object.keys(subExpr);
       const operator = subExprKeys.length == 1 ? subExprKeys[0] : "";
       const call = (0, import_core.getOperator)(
-        import_core.OperatorType.PROJECTION,
+        "projection",
         operator,
         options
       );
@@ -100,9 +85,9 @@ function processObject(obj, expr, options, expressionKeys, idOnlyExcluded) {
       } else if ((0, import_util.has)(obj, key)) {
         validateExpression(subExprObj, options);
         let target = obj[key];
-        if (target instanceof Array) {
+        if ((0, import_util.isArray)(target)) {
           value = target.map(
-            (o) => processObject(o, subExprObj, options, subExprKeys, false)
+            (o) => processObject(o, subExprObj, options, subExprKeys)
           );
         } else {
           target = (0, import_util.isObject)(target) ? target : obj;
@@ -110,8 +95,7 @@ function processObject(obj, expr, options, expressionKeys, idOnlyExcluded) {
             target,
             subExprObj,
             options,
-            subExprKeys,
-            false
+            subExprKeys
           );
         }
       } else {
@@ -124,12 +108,10 @@ function processObject(obj, expr, options, expressionKeys, idOnlyExcluded) {
     const objPathGraph = (0, import_util.resolveGraph)(obj, key, {
       preserveMissing: true
     });
-    if (objPathGraph !== void 0) {
-      (0, import_util.merge)(newObj, objPathGraph, {
-        flatten: true
-      });
+    if ((0, import_util.isObject)(objPathGraph)) {
+      (0, import_util.merge)(newObj, objPathGraph);
     }
-    if ((0, import_util.notInArray)([0, 1, false, true], subExpr)) {
+    if (!DESCRIPTORS.has(subExpr)) {
       if (value === void 0) {
         (0, import_util.removeValue)(newObj, key, { descendArray: true });
       } else {
@@ -151,8 +133,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/cjs/operators/pipeline/redact.js

@@ -23,7 +23,9 @@ module.exports = __toCommonJS(redact_exports);
 var import_core = require("../../core");
 const $redact = (collection, expr, options) => {
   const copts = import_core.ComputeOptions.init(options);
-  return collection.map((obj) => (0, import_core.redact)(obj, expr, copts.update(obj)));
+  return collection.map(
+    (obj) => (0, import_core.redact)(obj, expr, copts.update(obj))
+  );
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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

@@ -20,8 +20,15 @@ __export(replaceWith_exports, {
   $replaceWith: () => $replaceWith
 });
 module.exports = __toCommonJS(replaceWith_exports);
-var import_replaceRoot = require("./replaceRoot");
-const $replaceWith = import_replaceRoot.$replaceRoot;
+var import_core = require("../../core");
+var import_util = require("../../util");
+const $replaceWith = (collection, expr, options) => {
+  return collection.map((obj) => {
+    obj = (0, import_core.computeValue)(obj, expr, null, options);
+    (0, import_util.assert)((0, import_util.isObject)(obj), "$replaceWith expression must return an object");
+    return obj;
+  });
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   $replaceWith

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

@@ -25,8 +25,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 };
     };