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

package/package.json

@@ -95,5 +95,5 @@
         "darwin"
     ],
     "name": "@valkey/valkey-glide-darwin-arm64",
-    "version": "1.3.0-rc2"
+    "version": "1.3.0"
 }

package/rust-client/node_modules/mingo/README.md

@@ -29,7 +29,7 @@ MongoDB query language for in-memory objects
 
 For more documentation on how to use operators see [mongodb](http://docs.mongodb.org/manual/reference/operator/).
 
-Browse [package docs](http://kofrasa.github.io/mingo/) for modules.
+[API Documentation](http://kofrasa.github.io/mingo/).
 
 ## Usage
 
@@ -41,14 +41,14 @@ import mingo from "mingo";
 const mingo = require("mingo");
 ```
 
-The main module exports `Aggregator`, `Query`, `aggregate()`, `find()`, and `remove()`. Only [Query and Projection](https://docs.mongodb.com/manual/reference/operator/query/) operators are loaded by default when you require the main module. This is done using the side-effect module `mingo/init/basic` and automatically includes pipeline operators; `$project`, `$skip`, `$limit`, and `$sort`.
+The main module exports functions `aggregate`, `find`, `remove`, and `update`, and the objects `Aggregator` and `Query`. [Query and Projection](https://docs.mongodb.com/manual/reference/operator/query/) operators are loaded by default by the root through the side-effect module [init/basic](https://github.com/kofrasa/mingo/blob/main/src/init/basic.ts). This also automatically includes pipeline operators; `$project`, `$skip`, `$limit`, and `$sort`.
 
 ## Loading Operators
 
-MongoDB query library is huge and you may not need all the operators. If using this library on the server-side where bundle size is not a concern, you can load all operators as shown below.
+MongoDB query library is huge and you may not need all the operators. When using this library on the server-side where bundle size is not a concern, you can load all operators as shown below.
 
 ```js
-// Note that doing this effectively imports the entire library into your bundle and unused operators cannot be tree shaked
+// This effectively imports the entire library into your bundle.
 import "mingo/init/system";
 ```
 
@@ -64,8 +64,8 @@ To support tree-shaking for client side bundles, you can import and register spe
 
 ```js
 import { useOperators } from "mingo/core";
-import { $trunc } from "mingo/operators/expression";
-import { $bucket } from "mingo/operators/pipeline";
+import { $trunc } from "mingo/operators/expression/trunc";
+import { $bucket } from "mingo/operators/pipeline/bucket";
 
 useOperators("expression", { $trunc });
 useOperators("pipeline", { $bucket });
@@ -75,12 +75,11 @@ useOperators("pipeline", { $bucket });
 
 ```js
 const core = require("mingo/core");
-const $trunc = require("mingo/operators/expression").$trunc;
-const $bucket = require("mingo/operators/pipeline").$bucket;
-const useOperators = core.useOperators;
+const $trunc = require("mingo/operators/expression/trunc").$trunc;
+const $bucket = require("mingo/operators/pipeline/bucket").$bucket;
 
-useOperators("expression", { $trunc: $trunc });
-useOperators("pipeline", { $bucket: $bucket });
+core.useOperators("expression", { $trunc: $trunc });
+core.useOperators("pipeline", { $bucket: $bucket });
 ```
 
 ## Using query to test objects
@@ -143,8 +142,9 @@ No default implementation is provided out of the box so users can use a library
 The example below uses [Ajv](https://www.npmjs.com/package/ajv) to implement schema validation.
 
 ```js
-import { AnyObject } from "mingo/types"
-import { JsonSchemaValidator } from "mingo/core"
+import * as mingo from "mingo"
+import type { AnyObject } from "mingo/types"
+import type { JsonSchemaValidator } from "mingo/core"
 import Ajv, { Schema } from "ajv"
 
 const jsonSchemaValidator: JsonSchemaValidator = (s: AnyObject) => {
@@ -173,7 +173,7 @@ const schema = {
 };
 
 // queries documents using schema validation
-find(docs, { $jsonSchema: schema }, {}, { jsonSchemaValidator }).all();
+mingo.find(docs, { $jsonSchema: schema }, {}, { jsonSchemaValidator }).all();
 ```
 
 **Note:** An error is thrown when the `$jsonSchema` operator is used without a the `jsonSchemaValidator` configured.
@@ -207,27 +207,27 @@ let result = agg.run(collection);
 
 Query and aggregation operations can be configured with options to enabled different features or customize how documents are processed. Some options are only relevant to specific operators and need not be specified if not required.
 
-| Name                | Description                                                                                                                            | Default                                                                    | Behaviour                                                                                                                                                                                                                                                                                                                                           |
-| ------------------- | -------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| idKey               | The key that is used to lookup the ID value of a document.                                                                             | "\_id"                                                                     |                                                                                                                                                                                                                                                                                                                                                     |
-| collation           | [Collation](http://kofrasa.github.io/mingo/interfaces/core.CollationSpec.html) specification for string sorting operations.            | _none_                                                                     | See [Intl.Collator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Collator)                                                                                                                                                                                                                                 |
-| processingMode      | Determines copy rules for inputs and outputs.                                                                                          | [CLONE_OFF](http://kofrasa.github.io/mingo/enums/core.ProcessingMode.html) | Turn off cloning and modifies the input collection as needed. <br>This option will also return output objects with shared paths in their graph when specific operators are used. Provides the greatest speedup by minizing cloning. When using the aggregation pipeline, you can use the `$out` operator to collect immutable intermediate results. |
-| useStrictMode       | Enforces strict MongoDB compatibilty.                                                                                                  | true                                                                       | When disabled, behaviour changes as follows. <ul><li>`$elemMatch` returns all matching nested documents instead of only the first.</li><li>Empty string `""` is coerced to false during boolean checking in supported operators which is consistent with Javascript semantics.</li><li>`$type` returns JS native type names as follows. <ul><li>`"missing"` -> `"undefined"`</li><li>`"bool"` -> `"boolean"`</li><li> `"int"\|"long"\|"double"` -> `"number"`</li><li>`"regex"` -> `"regexp"`</li></ul><ul>                                                             |
-| scriptEnabled       | Enable or disable using custom script execution.                                                                                       | true                                                                       | When disabled, operators that execute custom code are disallowed such as; `$where`, `$accumulator`, and `$function`.                                                                                                                                                                                                                                |
-| hashFunction        | Custom hash function to replace the default based on "Effective Java" hashCode.                                                        | _default_                                                                  | Expects function `(value: unknown) => number`.                                                                                                                                                                                                                                                                                                      |
-| collectionResolver  | Function to resolve strings to arrays for use with operators that reference other collections such as; `$lookup`, `$out` and `$merge`. | _none_                                                                     | Expects function `(name: string) => AnyObject[]`                                                                                                                                                                                                                                                                                                    |
-| jsonSchemaValidator | JSON schema validator to use for the `$jsonSchema` operator.                                                                           | _none_                                                                     | Expects function `(schema: AnyObject) => (document: AnyObject) => boolean`.<br> The `$jsonSchema` operation would fail if a validator is not provided.                                                                                                                                                                                              |
-| variables           | Global variables to pass to all operators                                                                                              | _none_                                                                     |                                                                                                                                                                                                                                                                                                                                                     |
-| context             | Container to use for loading operators.                                                                                                | _none_                                                                     | This option allow users to load only desired operators or register custom operators which need not be available globally.                                                                                                                                                                                                                           |
-| useGlobalContext    | Allow falling back to the global context when operator is not found in the provided context.                                           | true                                                                       | This is provided to allow users to strictly enforce which operators may be usable.                                                                                                                                                                                                                                                                  |
+| Name | Default | Description |
+| -----| --------| ----------- |
+| collation |  _none_ | [Collation](http://kofrasa.github.io/mingo/interfaces/core.CollationSpec.html) specification for string sorting operations. See [Intl.Collator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Collator) |
+| collectionResolver | _none_ | <p>Function to resolve strings to arrays for use with operators that reference other collections such as; `$lookup`, `$out` and `$merge`.</p>Expects: `(string) => AnyObject[]`. |
+| context | _none_ | <p>An object that defines which operators should be used.</p>This option allow users to load only desired operators or register custom operators which need not be available globally. |
+| hashFunction | _default_ | <p>Custom hash function to replace the default based on "Effective Java" hashCode.</p>Expects: `(Any) => number`. |
+| idKey |  `"_id"` | <p>The key that is used to lookup the ID value of a document.</p> |
+| jsonSchemaValidator | _none_ | <p>JSON schema validator to use for the `$jsonSchema` operator.</p>Expects: `(schema: AnyObject) => (document: AnyObject) => boolean`.<br>The `$jsonSchema` operation would fail if a validator is not provided. |
+| processingMode |  [CLONE_OFF](http://kofrasa.github.io/mingo/enums/core.ProcessingMode.html) | <p>Specifies the degree of mutation for inputs and outputs. By default the input collection is modified as needed and returned output objects may share references.</p> Immutable intermediate results may be collected in a pipeline using the `$out` operator. |
+| scriptEnabled | `true` | <p>Enable or disable using custom script execution.</p>When disabled, operators that execute custom code are disallowed such as; `$where`, `$accumulator`, and `$function`. |
+| useGlobalContext | `true`| <p>Fallback to the global context if an operator is missing from the user-supplied context.</p>This is provided to allow users to strictly enforce which operators may be used. |
+| useStrictMode |  `true` | <p>Enforces strict MongoDB compatibilty.</p>When disabled the behaviour changes as follows. <ul><li>`$elemMatch` returns all matching nested documents instead of only the first.</li><li>Empty string `""` is coerced to false during boolean checking in supported operators which is consistent with Javascript semantics.</li><li>`$type` returns JS native type names as follows. <table><thead><tr><td>MongoDB</td><td>JavaScript</td></tr></thead><tr><td><code>"missing"</code></td><td><code>"undefined"</code></td></tr><tr><td><code>"bool"</code></td><td><code>"boolean"</code></td></tr><tr><td><code>"int"&#124;"long"&#124;"double"</code></td><td><code>"number"</code></td></tr><tr><td><code>"regex"</code></td><td><code>"regexp"</code></td></tr></table> |
+| variables | `{}` | Global variables to pass to all operators |
 
-## Adding Custom Operators
+## Custom Operators
 
-Custom operators can be registered using `Context` via the `context` option which is the recommended way from `6.4.2`. The `Context` is a container for operators, that the execution engine will use to process queries. Previously, the [useOperators(...)](https://kofrasa.github.io/mingo/functions/core.useOperators.html) function was used to register operators globally but that is no longer preferred. The difference between the two is that a globally registered operator cannot be overwritten whereas a new context may be created and used at anytime.
+Custom operators can be registered using a `Context` object via the `context` option which is the recommended way since `6.4.2`. `Context` provides a container for operators, that the execution engine will use to process queries. To register an operator globally, the [useOperators(...)](https://kofrasa.github.io/mingo/functions/core.useOperators.html) function is available. Globally registered operators cannot be overwritten whereas a new context may be created and used at anytime.
 
-**NB: Note that the execution engine will first try to find the operator in the context and fallback to the global context when not found.**
+**NB: Note that the execution engine will first try to find the operator in the context and fallback to the global context when not found if the `useGlobalContext` option is `true`.**
 
-Each operator type has a specific interface to which an implementation must conform to be valid.
+Custom operators must conform to the signatures of their types.
 
 - [AccumulatorOperator](http://kofrasa.github.io/mingo/types/core.AccumulatorOperator.html)
 - [ExpressionOperator](http://kofrasa.github.io/mingo/types/core.ExpressionOperator.html)
@@ -236,14 +236,57 @@ Each operator type has a specific interface to which an implementation must conf
 - [WindowOperator](http://kofrasa.github.io/mingo/types/core.WindowOperator.html)
 - [QueryOperator](http://kofrasa.github.io/mingo/types/core.QueryOperator.html)
 
-Pre-loaded operators defined [here](https://github.com/kofrasa/mingo/blob/master/src/init/basic.ts) cannot be overridden. These include;
+To define custom operators, the following imports are useful.
 
-- All [query](http://kofrasa.github.io/mingo/modules/operators_query.html) operators.
-- All [projection](http://kofrasa.github.io/mingo/modules/operators_projection.html) operators.
-- Expression operators for [boolean](http://kofrasa.github.io/mingo/modules/operators_expression_boolean.html) and [comparison](http://kofrasa.github.io/mingo/modules/operators_expression_comparison.html).
-- Pipeline [operators](http://kofrasa.github.io/mingo/modules/operators_pipeline.html); `$project`, `$skip`, `$limit`, and `$sort`.
+```js
+const mingo = require("mingo")
+const core = require("mingo/core");
+const util = require("mingo/util");
+```
+
+### Custom Operator Examples
+```js
+// this example creates a query operator that checks is a value is between a boundary.
+const $between = (selector, args, options) => {
+  return (obj) => {
+    const value = util.resolve(obj, selector, { unwrapArray: true });
+    return value >= args[0] && value <= args[1];
+  };
+}
+// a test collection
+const collection = [
+  { a: 1, b: 1 },
+  { a: 7, b: 1 },
+  { a: 10, b: 6 },
+  { a: 20, b: 10 }
+];
+```
+
+#### Register csutom operator using the context option.
+The custom operator is registerd with a user-provided context object that is passed an option to the query. The context will be searched for operators used in a query and fallback to the global context when not found.
 
-> NB: _Update operators is not supported in `Context`._
+```ts
+const context = core.Context.init().addQueryOps({ $between })
+// must specify context option to make operator available
+const result = mingo.find(collection, { a: { $between: [5, 10] } }, {}, { context }).all()
+console.log(result) // output => [ { a: 7, b: 1 }, { a: 10, b: 6 } ]
+```
+
+#### Register custom operator globally using useOperators.
+
+The custom operator is registered to be available globally.
+
+```ts
+// register the operator for global use.
+try {
+  core.useOperators("query", { $between })
+} catch {
+  // error thrown if an operator with name "$between" is already registered.
+}
+// query with new operator
+const result = mingo.find(collection, { a: { $between: [5, 10] }}).all()
+console.log(result) // output => [ { a: 7, b: 1 }, { a: 10, b: 6 } ]
+```
 
 ## Updating Documents
 
@@ -306,17 +349,13 @@ Below is a description of how this library differs from the full MongoDB query e
 
 1. There is no concept of a collection. Input is an array, generator or iterable of objects.
 1. Support a single numeric type `number`.
-1. When `useStrictMode` is `false`, replace MongoDB [types](https://www.mongodb.com/docs/manual/reference/operator/aggregation/type/#available-types) with JS native types as follows;
-   - `"bool"` -> `"boolean"`.
-   - `"int"|"long"|"double"|"decimal"` -> `"number"`.
-   - `"missing"` -> `"undefined"`.
 1. Does not support [types](https://www.mongodb.com/docs/manual/reference/operator/aggregation/type/#available-types) `"minKey"`, `"maxKey"`, `"timestamp"`, or `"binData"`.
 1. Does not support server specific operators. E.g. `$collStat`, `$planCacheStats`, `$listSessions`.
 1. Does not support geometry query operators.
 1. Does not support query operators dependent on persistent storage; `$comment`, `$meta`, `$text`.
 1. Does not support positional query or update operator `$`.
 1. Does not support server specific expression operators; `$toObjectId`, `$binarySize`, `bsonSize`.
-1. Agregation pipeline operator `$merge` enforces unique constraint on the lookup field during input processing.
+1. Aggregation pipeline operator `$merge` enforces unique constraint on the lookup field during input processing.
 1. Custom function evaluation operators; `$where`, `$function`, and `$accumulator`, do not accept strings as the function body.
 1. Custom function evaluation operators are enabled by default. They can be disabled with the `scriptEnabled` option.
 1. Custom function evaluation operator [$accumulator](https://docs.mongodb.com/manual/reference/operator/aggregation/accumulator/) does not support the `merge` option.

package/rust-client/node_modules/mingo/dist/cjs/aggregator.js

@@ -33,34 +33,30 @@ 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, options) {
-    let iterator = (0, import_lazy.Lazy)(collection);
+    let iter = (0, import_lazy.Lazy)(collection);
     const opts = options ?? this.#options;
     const mode = opts.processingMode;
-    if (mode == import_core.ProcessingMode.CLONE_ALL || mode == import_core.ProcessingMode.CLONE_INPUT) {
-      iterator.map(import_util.cloneDeep);
-    }
+    if (mode & import_core.ProcessingMode.CLONE_INPUT) iter.map(import_util.cloneDeep);
     const stages = new Array();
     if (!(0, import_util.isEmpty)(this.#pipeline)) {
-      for (const operator of this.#pipeline) {
-        const operatorKeys = Object.keys(operator);
-        const opName = operatorKeys[0];
+      for (const opExpr of this.#pipeline) {
+        const opKeys = Object.keys(opExpr);
+        const opName = opKeys[0];
         const call = (0, import_core.getOperator)("pipeline", opName, opts);
         (0, import_util.assert)(
-          operatorKeys.length === 1 && !!call,
+          opKeys.length === 1 && !!call,
           `invalid pipeline operator ${opName}`
         );
         stages.push(opName);
-        iterator = call(iterator, operator[opName], opts);
+        iter = call(iter, opExpr[opName], opts);
       }
     }
-    if (mode == import_core.ProcessingMode.CLONE_OUTPUT || mode == import_core.ProcessingMode.CLONE_ALL && !!(0, import_util.intersection)([["$group", "$unwind"], stages]).length) {
-      iterator.map(import_util.cloneDeep);
-    }
-    return iterator;
+    if (mode & import_core.ProcessingMode.CLONE_OUTPUT) iter.map(import_util.cloneDeep);
+    return iter;
   }
   /**
    * Return the results of the aggregation as an array.

package/rust-client/node_modules/mingo/dist/cjs/core.js

@@ -30,10 +30,10 @@ __export(core_exports, {
 module.exports = __toCommonJS(core_exports);
 var import_util = require("./util");
 var ProcessingMode = /* @__PURE__ */ ((ProcessingMode2) => {
-  ProcessingMode2["CLONE_ALL"] = "CLONE_ALL";
-  ProcessingMode2["CLONE_INPUT"] = "CLONE_INPUT";
-  ProcessingMode2["CLONE_OUTPUT"] = "CLONE_OUTPUT";
-  ProcessingMode2["CLONE_OFF"] = "CLONE_OFF";
+  ProcessingMode2[ProcessingMode2["CLONE_OFF"] = 0] = "CLONE_OFF";
+  ProcessingMode2[ProcessingMode2["CLONE_INPUT"] = 1] = "CLONE_INPUT";
+  ProcessingMode2[ProcessingMode2["CLONE_OUTPUT"] = 2] = "CLONE_OUTPUT";
+  ProcessingMode2[ProcessingMode2["CLONE_ALL"] = 3] = "CLONE_ALL";
   return ProcessingMode2;
 })(ProcessingMode || {});
 class ComputeOptions {
@@ -47,23 +47,18 @@ class ComputeOptions {
   }
   /**
    * Initialize new ComputeOptions.
-   *
-   * @param options
-   * @param root
-   * @param local
    * @returns {ComputeOptions}
    */
   static init(options, root, local) {
-    return options instanceof ComputeOptions ? new ComputeOptions(options.#options, options.root ?? root, {
+    return !(options instanceof ComputeOptions) ? new ComputeOptions(options, root, local) : new ComputeOptions(options.#options, options.root ?? root, {
       ...options.#local,
       ...local,
-      // retain existing variables
       variables: Object.assign(
         {},
         options.#local?.variables,
         local?.variables
       )
-    }) : new ComputeOptions(options, root, local);
+    });
   }
   /**
    * Updates the internal state.
@@ -105,7 +100,7 @@ class ComputeOptions {
     return this.#options?.collation;
   }
   get processingMode() {
-    return this.#options?.processingMode || "CLONE_OFF" /* CLONE_OFF */;
+    return this.#options?.processingMode || 0 /* CLONE_OFF */;
   }
   get useStrictMode() {
     return this.#options?.useStrictMode;
@@ -138,7 +133,7 @@ function initOptions(options) {
     scriptEnabled: true,
     useStrictMode: true,
     useGlobalContext: true,
-    processingMode: "CLONE_OFF" /* CLONE_OFF */,
+    processingMode: 0 /* CLONE_OFF */,
     ...options,
     context: options?.context ? Context.from(options?.context) : Context.init()
   });

package/rust-client/node_modules/mingo/dist/cjs/cursor.js

@@ -20,15 +20,20 @@ __export(cursor_exports, {
   Cursor: () => Cursor
 });
 module.exports = __toCommonJS(cursor_exports);
-var import_aggregator = require("./aggregator");
+var import_core = require("./core");
 var import_lazy = require("./lazy");
+var import_limit = require("./operators/pipeline/limit");
+var import_project = require("./operators/pipeline/project");
+var import_skip = require("./operators/pipeline/skip");
+var import_sort = require("./operators/pipeline/sort");
 var import_util = require("./util");
+const OPERATORS = { $sort: import_sort.$sort, $skip: import_skip.$skip, $limit: import_limit.$limit };
 class Cursor {
   #source;
   #predicate;
   #projection;
   #options;
-  #operators = [];
+  #operators = {};
   #result = null;
   #buffer = [];
   constructor(source, predicate, projection, options) {
@@ -40,15 +45,22 @@ class Cursor {
   /** Returns the iterator from running the query */
   fetch() {
     if (this.#result) return this.#result;
-    if ((0, import_util.isObject)(this.#projection)) {
-      this.#operators.push({ $project: this.#projection });
-    }
     this.#result = (0, import_lazy.Lazy)(this.#source).filter(this.#predicate);
-    if (this.#operators.length > 0) {
-      this.#result = new import_aggregator.Aggregator(this.#operators, this.#options).stream(
-        this.#result
-      );
+    const mode = this.#options.processingMode;
+    if (mode & import_core.ProcessingMode.CLONE_INPUT) this.#result.map(import_util.cloneDeep);
+    for (const op of ["$sort", "$skip", "$limit"]) {
+      if ((0, import_util.has)(this.#operators, op)) {
+        this.#result = OPERATORS[op](
+          this.#result,
+          this.#operators[op],
+          this.#options
+        );
+      }
+    }
+    if (Object.keys(this.#projection).length) {
+      this.#result = (0, import_project.$project)(this.#result, this.#projection, this.#options);
     }
+    if (mode & import_core.ProcessingMode.CLONE_OUTPUT) this.#result.map(import_util.cloneDeep);
     return this.#result;
   }
   /** Returns an iterator with the buffered data included */
@@ -77,7 +89,7 @@ class Cursor {
    * @return {Cursor} Returns the cursor, so you can chain this call.
    */
   skip(n) {
-    this.#operators.push({ $skip: n });
+    this.#operators["$skip"] = n;
     return this;
   }
   /**
@@ -86,7 +98,7 @@ class Cursor {
    * @return {Cursor} Returns the cursor, so you can chain this call.
    */
   limit(n) {
-    this.#operators.push({ $limit: n });
+    this.#operators["$limit"] = n;
     return this;
   }
   /**
@@ -95,7 +107,7 @@ class Cursor {
    * @return {Cursor} Returns the cursor, so you can chain this call.
    */
   sort(modifier) {
-    this.#operators.push({ $sort: modifier });
+    this.#operators["$sort"] = modifier;
     return this;
   }
   /**

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

@@ -48,7 +48,6 @@ function createQueryOperator(predicate) {
       return predicate(lhs, value, { ...options, depth });
     };
   };
-  f.op = "query";
   return f;
 }
 function createExpressionOperator(predicate) {

package/rust-client/node_modules/mingo/dist/cjs/operators/accumulator/bottomN.js

@@ -20,8 +20,9 @@ __export(bottomN_exports, {
   $bottomN: () => $bottomN
 });
 module.exports = __toCommonJS(bottomN_exports);
-var import_aggregator = require("../../aggregator");
 var import_core = require("../../core");
+var import_lazy = require("../../lazy");
+var import_sort = require("../pipeline/sort");
 var import_push = require("./push");
 const $bottomN = (collection, expr, options) => {
   const copts = import_core.ComputeOptions.init(options);
@@ -31,7 +32,7 @@ const $bottomN = (collection, expr, options) => {
     null,
     copts
   );
-  const result = new import_aggregator.Aggregator([{ $sort: sortBy }], copts).run(collection);
+  const result = (0, import_sort.$sort)((0, import_lazy.Lazy)(collection), sortBy, options).value();
   const m = result.length;
   const p = n;
   return (0, import_push.$push)(m <= p ? result : result.slice(m - p), expr.output, copts);

package/rust-client/node_modules/mingo/dist/cjs/operators/accumulator/topN.js

@@ -20,8 +20,9 @@ __export(topN_exports, {
   $topN: () => $topN
 });
 module.exports = __toCommonJS(topN_exports);
-var import_aggregator = require("../../aggregator");
 var import_core = require("../../core");
+var import_lazy = require("../../lazy");
+var import_sort = require("../pipeline/sort");
 var import_push = require("./push");
 const $topN = (collection, expr, options) => {
   const copts = import_core.ComputeOptions.init(options);
@@ -31,9 +32,7 @@ const $topN = (collection, expr, options) => {
     null,
     copts
   );
-  const result = new import_aggregator.Aggregator([{ $sort: sortBy }, { $limit: n }], copts).run(
-    collection
-  );
+  const result = (0, import_sort.$sort)((0, import_lazy.Lazy)(collection), sortBy, options).take(n).value();
   return (0, import_push.$push)(result, expr.output, copts);
 };
 // Annotate the CommonJS export names for ESM import in node:

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/array/sortArray.js

@@ -20,15 +20,16 @@ __export(sortArray_exports, {
   $sortArray: () => $sortArray
 });
 module.exports = __toCommonJS(sortArray_exports);
-var import_aggregator = require("../../../aggregator");
 var import_core = require("../../../core");
+var import_lazy = require("../../../lazy");
 var import_util = require("../../../util");
+var import_sort = require("../../pipeline/sort");
 const $sortArray = (obj, expr, options) => {
   const { input, sortBy } = (0, import_core.computeValue)(obj, expr, null, options);
   if ((0, import_util.isNil)(input)) return null;
   (0, import_util.assert)((0, import_util.isArray)(input), "$sortArray expression must resolve to an array");
   if ((0, import_util.isObject)(sortBy)) {
-    return new import_aggregator.Aggregator([{ $sort: sortBy }]).run(input);
+    return (0, import_sort.$sort)((0, import_lazy.Lazy)(input), sortBy, options).value();
   }
   const result = [...input];
   result.sort(import_util.compare);

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

@@ -48,7 +48,7 @@ const $fill = (collection, expr, options) => {
   options = (0, import_core.initOptions)(options);
   options.context.addExpressionOps({ $ifNull: import_ifNull.$ifNull });
   options.context.addWindowOps({ $locf: import_locf.$locf, $linearFill: import_linearFill.$linearFill });
-  const partitionExpr = expr.partitionBy || expr?.partitionByFields?.map((s) => `$${s}`);
+  const partitionExpr = expr.partitionBy || expr?.partitionByFields?.map((s) => "$" + s);
   const valueExpr = {};
   const methodExpr = {};
   for (const [k, m] of Object.entries(expr.output)) {

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

@@ -62,11 +62,10 @@ const $lookup = (collection, expr, options) => {
     }
   }
   const agg = new import_aggregator.Aggregator(subQueryPipeline, options);
+  const opts = { ...options };
   return collection.map((obj) => {
-    const variables = (0, import_core.computeValue)(obj, letExpr, null, options);
-    const opts = Object.assign({}, options, {
-      variables: { ...options.variables, ...variables }
-    });
+    const vars = (0, import_core.computeValue)(obj, letExpr, null, options);
+    opts.variables = { ...options.variables, ...vars };
     const [ok, res] = lookupEq(obj);
     return {
       ...obj,