@valkey/valkey-glide-darwin-arm64 1.3.0-rc2 → 1.3.0

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

@@ -1,6 +1,11 @@
 import { isEqual } from "../../util";
-import { applyUpdate, clone, walkExpression } from "./_internal";
-const $set = (obj, expr, arrayFilters = [], options = {}) => {
+import {
+  applyUpdate,
+  clone,
+  UPDATE_OPTIONS,
+  walkExpression
+} from "./_internal";
+const $set = (obj, expr, arrayFilters = [], options = UPDATE_OPTIONS) => {
   return walkExpression(expr, arrayFilters, options, (val, node, queries) => {
     return applyUpdate(
       obj,

package/rust-client/node_modules/mingo/dist/esm/operators/update/unset.js

@@ -1,6 +1,6 @@
 import { has, isArray } from "../../util";
-import { applyUpdate, walkExpression } from "./_internal";
-const $unset = (obj, expr, arrayFilters = [], options = {}) => {
+import { applyUpdate, UPDATE_OPTIONS, walkExpression } from "./_internal";
+const $unset = (obj, expr, arrayFilters = [], options = UPDATE_OPTIONS) => {
   return walkExpression(expr, arrayFilters, options, (_, node, queries) => {
     return applyUpdate(obj, node, queries, (o, k) => {
       if (!has(o, k)) return false;

package/rust-client/node_modules/mingo/dist/esm/query.js

@@ -1,6 +1,6 @@
 import { getOperator, initOptions } from "./core";
 import { Cursor } from "./cursor";
-import { assert, isObject, isOperator, MingoError, normalize } from "./util";
+import { assert, cloneDeep, isObject, isOperator, normalize } from "./util";
 const TOP_LEVEL_OPS = new Set(
   Array.from(["$and", "$or", "$nor", "$expr", "$jsonSchema"])
 );
@@ -9,7 +9,7 @@ class Query {
   #options;
   #condition;
   constructor(condition, options) {
-    this.#condition = condition;
+    this.#condition = cloneDeep(condition);
     this.#options = initOptions(options);
     this.#compiled = [];
     this.compile();
@@ -22,6 +22,10 @@ class Query {
     const whereOperator = {};
     for (const [field, expr] of Object.entries(this.#condition)) {
       if ("$where" === field) {
+        assert(
+          this.#options.scriptEnabled,
+          "$where operator requires 'scriptEnabled' option to be true."
+        );
         Object.assign(whereOperator, { field, expr });
       } else if (TOP_LEVEL_OPS.has(field)) {
         this.processOperator(field, field, expr);
@@ -44,25 +48,17 @@ class Query {
   }
   processOperator(field, operator, value) {
     const call = getOperator("query", operator, this.#options);
-    if (!call) {
-      throw new MingoError(`unknown query operator ${operator}`);
-    }
-    const fn = call(field, value, this.#options);
-    this.#compiled.push(fn);
+    assert(!!call, `unknown query operator ${operator}`);
+    this.#compiled.push(call(field, value, this.#options));
   }
   /**
    * Checks if the object passes the query criteria. Returns true if so, false otherwise.
    *
    * @param obj The object to test
-   * @returns {boolean} True or false
+   * @returns {boolean}
    */
   test(obj) {
-    for (let i = 0, len = this.#compiled.length; i < len; i++) {
-      if (!this.#compiled[i](obj)) {
-        return false;
-      }
-    }
-    return true;
+    return this.#compiled.every((p) => p(obj));
   }
   /**
    * Returns a cursor to select matching documents from the input source.
@@ -74,7 +70,7 @@ class Query {
   find(collection, projection) {
     return new Cursor(
       collection,
-      (x) => this.test(x),
+      (o) => this.test(o),
       projection || {},
       this.#options
     );

package/rust-client/node_modules/mingo/dist/esm/updater.js

@@ -1,24 +1,10 @@
-import { initOptions } from "./core";
-import * as booleanOperators from "./operators/expression/boolean";
-import * as comparisonOperators from "./operators/expression/comparison";
-import * as queryOperators from "./operators/query";
 import * as UPDATE_OPERATORS from "./operators/update";
+import { UPDATE_OPTIONS } from "./operators/update/_internal";
 import { Query } from "./query";
 import { assert, has } from "./util";
 function createUpdater(defaultOptions) {
-  defaultOptions = defaultOptions || {};
-  defaultOptions = {
-    ...defaultOptions,
-    queryOptions: initOptions(defaultOptions.queryOptions)
-  };
-  defaultOptions.queryOptions.context.addQueryOps(queryOperators).addExpressionOps(booleanOperators).addExpressionOps(comparisonOperators);
-  return (obj, expr, arrayFilters = [], condition = {}, options = {}) => {
-    const opts = Object.assign({ cloneMode: "copy" }, defaultOptions, options);
-    Object.assign(opts, {
-      queryOptions: initOptions(
-        Object.assign({ useStrictMode: false }, opts?.queryOptions)
-      )
-    });
+  defaultOptions = defaultOptions ?? UPDATE_OPTIONS;
+  return (obj, expr, arrayFilters = [], condition = {}, options = defaultOptions) => {
     const entry = Object.entries(expr);
     assert(
       entry.length === 1,
@@ -31,10 +17,10 @@ function createUpdater(defaultOptions) {
     );
     const mutate = UPDATE_OPERATORS[op];
     if (Object.keys(condition).length) {
-      const q = condition instanceof Query ? condition : new Query(condition, opts.queryOptions);
+      const q = new Query(condition, options.queryOptions);
       if (!q.test(obj)) return [];
     }
-    return mutate(obj, args, arrayFilters, opts);
+    return mutate(obj, args, arrayFilters, options);
   };
 }
 const update = createUpdater();

package/rust-client/node_modules/mingo/dist/esm/util.js

@@ -11,9 +11,6 @@ const DEFAULT_HASH_FUNCTION = (value) => {
   while (i) hash = (hash << 5) - hash ^ s.charCodeAt(--i);
   return hash >>> 0;
 };
-const objectProto = Object.prototype;
-const arrayProto = Array.prototype;
-const getPrototypeOf = Object.getPrototypeOf;
 const isPrimitive = (v) => typeof v !== "object" && typeof v !== "function" || v === null;
 const isScalar = (v) => isPrimitive(v) || isDate(v) || isRegExp(v);
 const SORT_ORDER = {
@@ -123,7 +120,7 @@ function assert(condition, message) {
   if (!condition) throw new MingoError(message);
 }
 const typeOf = (v) => {
-  const s = objectProto.toString.call(v);
+  const s = Object.prototype.toString.call(v);
   const t = s.substring(8, s.length - 1).toLowerCase();
   if (t !== "object") return t;
   const ctor = v.constructor;
@@ -148,7 +145,7 @@ const isNil = (v) => v === null || v === void 0;
 const truthy = (arg, strict = true) => !!arg || strict && arg === "";
 const isEmpty = (x) => isNil(x) || isString(x) && !x || isArray(x) && x.length === 0 || isObject(x) && Object.keys(x).length === 0;
 const ensureArray = (x) => isArray(x) ? x : [x];
-const has = (obj, prop) => !!obj && objectProto.hasOwnProperty.call(obj, prop);
+const has = (obj, prop) => !!obj && Object.prototype.hasOwnProperty.call(obj, prop);
 const isTypedArray = (v) => typeof ArrayBuffer !== "undefined" && ArrayBuffer.isView(v);
 const cloneDeep = (v, refs) => {
   if (isNil(v) || isBoolean(v) || isNumber(v) || isString(v)) return v;
@@ -223,23 +220,39 @@ function flatten(xs, depth = 1) {
   flatten2(xs, depth);
   return arr;
 }
+const objToString = Object.prototype.toString;
+function hasCustomToString(o) {
+  if (isTypedArray(o)) return true;
+  if (typeof o.toString === "function") {
+    let proto = Object.getPrototypeOf(o);
+    while (proto !== null) {
+      if (has(proto, "toString") && proto.toString !== objToString) {
+        return true;
+      }
+      proto = Object.getPrototypeOf(proto);
+    }
+  }
+  return false;
+}
 function isEqual(a, b) {
   if (a === b || Object.is(a, b)) return true;
-  const ctor = !!a && a.constructor || a;
-  if (a === null || b === null || a === void 0 || b === void 0 || ctor !== b.constructor || ctor === Function) {
-    return false;
-  }
+  if (a === null || b === null) return false;
+  if (typeof a !== typeof b) return false;
+  if (typeof a !== "object") return false;
+  if (a.constructor !== b.constructor) return false;
+  if (a instanceof Date) return +a === +b;
+  if (a instanceof RegExp) return a.toString() === b.toString();
+  const ctor = a.constructor;
   if (ctor === Array || ctor === Object) {
-    const aKeys = Object.keys(a);
-    const bKeys = Object.keys(b);
+    const aKeys = Object.keys(a).sort();
+    const bKeys = Object.keys(b).sort();
     if (aKeys.length !== bKeys.length) return false;
-    if ((/* @__PURE__ */ new Set([...aKeys, ...bKeys])).size != aKeys.length) return false;
-    for (const k of aKeys) if (!isEqual(a[k], b[k])) return false;
+    for (let i = 0, k = aKeys[i]; i < aKeys.length; k = aKeys[++i]) {
+      if (k !== bKeys[i] || !isEqual(a[k], b[k])) return false;
+    }
     return true;
   }
-  const proto = getPrototypeOf(a);
-  const cmp = isTypedArray(a) || proto !== objectProto && proto !== arrayProto && has(proto, "toString");
-  return cmp && a.toString() === b.toString();
+  return hasCustomToString(a) && a.toString() === b.toString();
 }
 function unique(input, hashFunction = DEFAULT_HASH_FUNCTION) {
   const m = ValueMap.init(hashFunction);
@@ -264,8 +277,7 @@ const stringify = (v, refs) => {
       const keys = Object.keys(v).sort();
       return "{" + keys.map((k) => `${k}:${stringify(v[k], refs)}`).join() + "}";
     }
-    const proto = Object.getPrototypeOf(v);
-    if (proto !== objectProto && proto !== arrayProto && has(proto, "toString")) {
+    if (hasCustomToString(v)) {
       return typeOf(v) + "(" + JSON.stringify(v.toString()) + ")";
     }
     throw new Error(

package/rust-client/node_modules/mingo/dist/types/aggregator.d.ts

@@ -14,7 +14,7 @@ export declare class Aggregator {
     /**
      * Returns an {@link Iterator} for lazy evaluation of the pipeline.
      *
-     * @param {*} collection An array or iterator object
+     * @param collection An array or iterator object
      * @returns {Iterator} an iterator object
      */
     stream(collection: Source, options?: Options): Iterator;

package/rust-client/node_modules/mingo/dist/types/core.d.ts

@@ -22,38 +22,17 @@ export interface CollationSpec {
  */
 export type JsonSchemaValidator = (schema: AnyObject) => Predicate<AnyObject>;
 /**
- * This controls how input and output documents are processed to meet different application needs.
- * Each mode has different trade offs for; immutability, reference sharing, and performance.
+ * Specified how input and output documents are processed.
  */
 export declare enum ProcessingMode {
-    /**
-     * Clone inputs prior to processing, and the outputs if some objects graphs may be shared.
-     * Use this option to keep input collection immutable and to get distinct output objects.
-     *
-     * Note: This option is expensive and reduces performance.
-     */
-    CLONE_ALL = "CLONE_ALL",
-    /**
-     * Clones inputs prior to processing.
-     * This option will return output objects with shared graphs in their path if specific operators are used.
-     * Use this option to keep the input collection immutable.
-     *
-     */
-    CLONE_INPUT = "CLONE_INPUT",
-    /**
-     * Clones the output to return distinct objects with no shared paths.
-     * This option modifies the input collection and during processing.
-     */
-    CLONE_OUTPUT = "CLONE_OUTPUT",
-    /**
-     * Turn off cloning and modifies the input collection as needed.
-     * This option will also return output objects with shared paths in their graph when specific operators are used.
-     * This option provides the greatest speedup for the biggest tradeoff.
-     * When using the aggregation pipeline, you can use the "$out" operator to collect immutable intermediate results.
-     *
-     * @default
-     */
-    CLONE_OFF = "CLONE_OFF"
+    /** Do not clone inputs or outputs. Resulting documents may share references. @default */
+    CLONE_OFF = 0,
+    /** Clone input documents to maintain immutability of original input. */
+    CLONE_INPUT = 1,
+    /** Clone output documents to ensure distinct objects without shared references. */
+    CLONE_OUTPUT = 2,
+    /** Clone input and output documents. */
+    CLONE_ALL = 3
 }
 /**
  * Generic options interface passed down to all operators
@@ -67,7 +46,7 @@ export interface Options {
     readonly processingMode: ProcessingMode;
     /** Enforces strict MongoDB compatibilty. See README. @default true. */
     readonly useStrictMode: boolean;
-    /** Enable or disable custom script execution via $where, $accumulator, and $function operators. @default true. */
+    /** Enable or disable custom script execution using `$where`, `$accumulator`, and `$function` operators. @default true. */
     readonly scriptEnabled: boolean;
     /** Enable or disable falling back to the global context for operators. @default true. */
     readonly useGlobalContext: boolean;
@@ -94,10 +73,6 @@ export declare class ComputeOptions implements Options {
     private constructor();
     /**
      * Initialize new ComputeOptions.
-     *
-     * @param options
-     * @param root
-     * @param local
      * @returns {ComputeOptions}
      */
     static init(options: Options, root?: Any, local?: LocalData): ComputeOptions;

package/rust-client/node_modules/mingo/dist/types/operators/pipeline/project.d.ts

@@ -1,6 +1,7 @@
 import { PipelineOperator } from "../../core";
 /**
- * Reshapes each document in the stream, such as by adding new fields or removing existing fields. For each input document, outputs one document.
+ * Reshapes each document in the stream, such as by adding new fields or removing existing fields.
+ * For each input document, outputs one document.
  *
  * See {@link https://www.mongodb.com/docs/manual/reference/operator/aggregation/project usage}.
  *

package/rust-client/node_modules/mingo/dist/types/operators/update/_internal.d.ts

@@ -2,6 +2,7 @@ import { CloneMode, UpdateOptions } from "../../core";
 import { Query } from "../../query";
 import { Any, AnyObject, ArrayOrObject, Callback } from "../../types";
 import { WalkOptions } from "../../util";
+export declare const UPDATE_OPTIONS: UpdateOptions;
 export declare const clone: (mode: CloneMode, val: Any) => Any;
 export type PathNode = {
     selector: string;

package/rust-client/node_modules/mingo/dist/types/query.d.ts

@@ -18,7 +18,7 @@ export declare class Query {
      * Checks if the object passes the query criteria. Returns true if so, false otherwise.
      *
      * @param obj The object to test
-     * @returns {boolean} True or false
+     * @returns {boolean}
      */
     test<T>(obj: T): boolean;
     /**

package/rust-client/node_modules/mingo/dist/types/util.d.ts

@@ -108,9 +108,9 @@ export declare function flatten(xs: Any[], depth?: number): Any[];
  * For user-defined objects this checks for only referential equality so
  * two different instances with the same values are not equal.
  *
- * @param  {*}  a The first value
- * @param  {*}  b The second value
- * @return {Boolean} True if value contents are the same, false otherwise.
+ * @param a The first value
+ * @param b The second value
+ * @return True if values are equivalent, false otherwise.
  */
 export declare function isEqual(a: Any, b: Any): boolean;
 /**

package/rust-client/node_modules/mingo/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mingo",
-  "version": "6.5.2",
+  "version": "6.5.3",
   "description": "MongoDB query language for in-memory objects",
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.js",