@azure/cosmos 4.9.1 → 4.9.2

package/dist/commonjs/queryExecutionContext/queryFilteringStrategy/RidSkipCountFilter.js

@@ -1,184 +1,154 @@
-"use strict";
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RidSkipCountFilter = void 0;
-const orderByComparator_js_1 = require("../orderByComparator.js");
-/**
- * Implements post-fetch filtering for ORDER BY queries to handle continuation tokens correctly.
- * This logic is applied only to the target partition from which a query is resumed.
- * It filters out documents that have already been emitted in previous pages by comparing
- * ORDER BY item values first, then document _rid, and finally using skip count for tie-breaking.
- *
- * Follows the .NET SDK FilterNextAsync logic:
- * 1. Compare OrderBy values with continuation token values
- * 2. Skip documents that come before continuation point
- * 3. For exact OrderBy matches, use RID comparison
- * 4. For exact RID matches, apply skip count logic
- */
+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 RidSkipCountFilter_exports = {};
+__export(RidSkipCountFilter_exports, {
+  RidSkipCountFilter: () => RidSkipCountFilter
+});
+module.exports = __toCommonJS(RidSkipCountFilter_exports);
+var import_orderByComparator = require("../orderByComparator.js");
 class RidSkipCountFilter {
-    filterContext;
-    remainingSkipCount;
-    /**
-     * @param filterContext - The context containing values from the continuation token.
-     */
-    constructor(filterContext) {
-        this.filterContext = filterContext;
-        this.remainingSkipCount = this.filterContext.skipCount;
+  /**
+   * @param filterContext - The context containing values from the continuation token.
+   */
+  constructor(filterContext) {
+    this.filterContext = filterContext;
+    this.remainingSkipCount = this.filterContext.skipCount;
+  }
+  remainingSkipCount;
+  /**
+   * Applies the comprehensive OrderBy + RID + SkipCount filtering logic.
+   * @param documents - The documents fetched from the target partition.
+   * @returns A new array containing only the documents that should be processed.
+   */
+  applyFilter(documents) {
+    const filteredDocs = [];
+    let skippedCount = 0;
+    for (const doc of documents) {
+      if (!this.shouldIncludeDocument(doc)) {
+        skippedCount++;
+        continue;
+      }
+      filteredDocs.push(doc);
     }
-    /**
-     * Applies the comprehensive OrderBy + RID + SkipCount filtering logic.
-     * @param documents - The documents fetched from the target partition.
-     * @returns A new array containing only the documents that should be processed.
-     */
-    applyFilter(documents) {
-        const filteredDocs = [];
-        let skippedCount = 0;
-        for (const doc of documents) {
-            if (!this.shouldIncludeDocument(doc)) {
-                skippedCount++;
-                continue;
-            }
-            filteredDocs.push(doc);
-        }
-        return filteredDocs;
+    return filteredDocs;
+  }
+  /**
+   * Determines if a document should be included based on OrderBy values, RID, and skip count.
+   * Implements the .NET SDK's FilterNextAsync logic with robust OrderBy comparison.
+   */
+  shouldIncludeDocument(doc) {
+    const sortOrderCompare = this.compareOrderByItems(doc);
+    if (sortOrderCompare < 0) {
+      return true;
     }
-    /**
-     * Determines if a document should be included based on OrderBy values, RID, and skip count.
-     * Implements the .NET SDK's FilterNextAsync logic with robust OrderBy comparison.
-     */
-    shouldIncludeDocument(doc) {
-        // Step 1: OrderBy Value Filtering using OrderByComparator
-        const sortOrderCompare = this.compareOrderByItems(doc);
-        // FIXED: Correct the inverted logic!
-        // compareOrderByItems returns: negative if doc < continuation, positive if doc > continuation
-        // But for filtering: negative means doc comes BEFORE (skip), positive means doc comes AFTER (include)
-        // If sortOrderCompare < 0, this document comes before the continuation point
-        if (sortOrderCompare < 0) {
-            return true; // Include documents that come after continuation point
-        }
-        // If sortOrderCompare > 0, this document comes after the continuation point
-        if (sortOrderCompare > 0) {
-            return false; // Skip documents that come before continuation point
-        }
-        // Step 2: RID Filtering (sortOrderCompare === 0, same OrderBy values)
-        // Check if RID is available for comparison (some queries like JOIN may not have RID)
-        // if (!this.filterContext.rid) {
-        //    //   // Without RID, we can't do RID-based filtering, so include the document
-        //   // The skipCount logic will handle any necessary filtering
-        //   if (this.remainingSkipCount > 0) {
-        //    //     this.remainingSkipCount--;
-        //     return false;
-        //   }
-        //    //   return true;
-        // }
-        // For ORDER BY queries, _rid is at the top level of doc, not in payload
-        // Query rewrites to: SELECT c._rid, [...] AS orderByItems, {...} AS payload
-        const docRid = doc._rid;
-        let ridOrderCompare;
-        if (this.filterContext.rid === docRid) {
-            ridOrderCompare = 0;
-        }
-        else {
-            // Use BigInt comparison for accurate RID comparison
-            const continuationBigInt = this.ridToBigInt(this.filterContext.rid);
-            const docBigInt = this.ridToBigInt(docRid);
-            if (continuationBigInt < docBigInt) {
-                ridOrderCompare = -1;
-            }
-            else if (continuationBigInt > docBigInt) {
-                ridOrderCompare = 1;
-            }
-            else {
-                ridOrderCompare = 0;
-            }
-        }
-        // Apply direction logic based on sort order and query execution info
-        const sortOrders = this.filterContext.sortOrders || [];
-        const queryExecutionInfo = this.filterContext.queryExecutionInfo;
-        // Direction logic based on index scan direction
-        // Find the first descending sort order in the array
-        const hasDescendingSort = sortOrders.some((order) => order === "Descending");
-        if (!queryExecutionInfo || queryExecutionInfo.reverseRidEnabled) {
-            // Default behavior or when reverseRidEnabled is true
-            if (hasDescendingSort) {
-                ridOrderCompare = -ridOrderCompare; // Flip for DESC sort order
-            }
-        }
-        else {
-            // When reverseRidEnabled is false, use reverseIndexScan
-            if (queryExecutionInfo.reverseIndexScan) {
-                ridOrderCompare = -ridOrderCompare; // Flip based on index scan direction
-            }
-        }
-        // if (ridOrderCompare > 0) continue; // Skip
-        if (ridOrderCompare > 0) {
-            return false; // Skip documents that were already processed
-        }
-        if (ridOrderCompare < 0) {
-            return true; // Include documents that come after continuation
-        }
-        // Step 3: SkipCount Logic (ridOrderCompare === 0, exact same RID)
-        if (this.remainingSkipCount > 0) {
-            this.remainingSkipCount--;
-            return false; // Skip this document due to skip count
-        }
-        return true; // Include this document (skip count exhausted)
+    if (sortOrderCompare > 0) {
+      return false;
     }
-    /**
-     * Convert RID to BigInt for accurate comparison.
-     * Decodes base64 RID and extracts the Document ID portion (8 bytes at offset 8) as BigInt.
-     *
-     * RID Structure (from Java SDK ResourceId.java):
-     * - Bytes 0-3: Database ID (4 bytes)
-     * - Bytes 4-7: Collection ID (4 bytes)
-     * - Bytes 8-15: Document ID (8 bytes, stored in Big Endian but compared in Little Endian)
-     * - Bytes 16-19: Attachment ID (4 bytes, optional)
-     */
-    ridToBigInt(rid) {
-        // Validate input RID
-        if (rid === null || rid === undefined) {
-            throw new Error(`RID is null or undefined`);
-        }
-        if (typeof rid !== "string") {
-            throw new Error(`RID must be a string, got ${typeof rid}`);
-        }
-        if (rid.trim().length === 0) {
-            throw new Error(`RID is empty string`);
-        }
-        try {
-            const normalizedRid = rid.replace(/-/g, "/");
-            const bytes = Buffer.from(normalizedRid, "base64");
-            // Validate RID length - must be at least 16 bytes to contain document ID
-            if (bytes.length < 16) {
-                throw new Error(`RID too short: expected at least 16 bytes, got ${bytes.length}`);
-            }
-            // Extract Document ID portion (8 bytes at offset 8-15)
-            // The bytes are stored as Big Endian but must be compared as Little Endian
-            let result = 0n;
-            for (let i = 15; i >= 8; i--) {
-                result = (result << 8n) | BigInt(bytes[i] & 0xff); // & 0xFF treats as unsigned
-            }
-            return result;
-        }
-        catch (error) {
-            throw new Error(`Failed to convert RID '${rid}' to BigInt: ${error instanceof Error ? error.message : String(error)}`);
-        }
+    const docRid = doc._rid;
+    let ridOrderCompare;
+    if (this.filterContext.rid === docRid) {
+      ridOrderCompare = 0;
+    } else {
+      const continuationBigInt = this.ridToBigInt(this.filterContext.rid);
+      const docBigInt = this.ridToBigInt(docRid);
+      if (continuationBigInt < docBigInt) {
+        ridOrderCompare = -1;
+      } else if (continuationBigInt > docBigInt) {
+        ridOrderCompare = 1;
+      } else {
+        ridOrderCompare = 0;
+      }
     }
-    /**
-     * Compares the OrderBy items of a document with the continuation token's OrderBy items.
-     * Uses the exported compareOrderByItems utility function from orderByItemComparator.
-     * @param doc - The document to compare
-     * @returns negative if doc comes before continuation, 0 if same, positive if doc comes after
-     */
-    compareOrderByItems(doc) {
-        const docOrderByItems = doc.orderByItems || [];
-        const continuationOrderByItems = this.filterContext.orderByItems || [];
-        const sortOrders = this.filterContext.sortOrders || [];
-        // Compare doc vs continuation (not continuation vs doc!)
-        // Returns: negative if doc < continuation, 0 if equal, positive if doc > continuation
-        return (0, orderByComparator_js_1.compareOrderByItems)(docOrderByItems, continuationOrderByItems, sortOrders);
+    const sortOrders = this.filterContext.sortOrders || [];
+    const queryExecutionInfo = this.filterContext.queryExecutionInfo;
+    const hasDescendingSort = sortOrders.some((order) => order === "Descending");
+    if (!queryExecutionInfo || queryExecutionInfo.reverseRidEnabled) {
+      if (hasDescendingSort) {
+        ridOrderCompare = -ridOrderCompare;
+      }
+    } else {
+      if (queryExecutionInfo.reverseIndexScan) {
+        ridOrderCompare = -ridOrderCompare;
+      }
     }
+    if (ridOrderCompare > 0) {
+      return false;
+    }
+    if (ridOrderCompare < 0) {
+      return true;
+    }
+    if (this.remainingSkipCount > 0) {
+      this.remainingSkipCount--;
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Convert RID to BigInt for accurate comparison.
+   * Decodes base64 RID and extracts the Document ID portion (8 bytes at offset 8) as BigInt.
+   *
+   * RID Structure (from Java SDK ResourceId.java):
+   * - Bytes 0-3: Database ID (4 bytes)
+   * - Bytes 4-7: Collection ID (4 bytes)
+   * - Bytes 8-15: Document ID (8 bytes, stored in Big Endian but compared in Little Endian)
+   * - Bytes 16-19: Attachment ID (4 bytes, optional)
+   */
+  ridToBigInt(rid) {
+    if (rid === null || rid === void 0) {
+      throw new Error(`RID is null or undefined`);
+    }
+    if (typeof rid !== "string") {
+      throw new Error(`RID must be a string, got ${typeof rid}`);
+    }
+    if (rid.trim().length === 0) {
+      throw new Error(`RID is empty string`);
+    }
+    try {
+      const normalizedRid = rid.replace(/-/g, "/");
+      const bytes = Buffer.from(normalizedRid, "base64");
+      if (bytes.length < 16) {
+        throw new Error(`RID too short: expected at least 16 bytes, got ${bytes.length}`);
+      }
+      let result = 0n;
+      for (let i = 15; i >= 8; i--) {
+        result = result << 8n | BigInt(bytes[i] & 255);
+      }
+      return result;
+    } catch (error) {
+      throw new Error(
+        `Failed to convert RID '${rid}' to BigInt: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  /**
+   * Compares the OrderBy items of a document with the continuation token's OrderBy items.
+   * Uses the exported compareOrderByItems utility function from orderByItemComparator.
+   * @param doc - The document to compare
+   * @returns negative if doc comes before continuation, 0 if same, positive if doc comes after
+   */
+  compareOrderByItems(doc) {
+    const docOrderByItems = doc.orderByItems || [];
+    const continuationOrderByItems = this.filterContext.orderByItems || [];
+    const sortOrders = this.filterContext.sortOrders || [];
+    return (0, import_orderByComparator.compareOrderByItems)(docOrderByItems, continuationOrderByItems, sortOrders);
+  }
 }
-exports.RidSkipCountFilter = RidSkipCountFilter;
-//# sourceMappingURL=RidSkipCountFilter.js.map
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RidSkipCountFilter
+});

package/dist/commonjs/queryExecutionContext/queryFilteringStrategy/RidSkipCountFilter.js.map

@@ -1 +1,7 @@
-{"version":3,"file":"RidSkipCountFilter.js","sourceRoot":"","sources":["../../../../src/queryExecutionContext/queryFilteringStrategy/RidSkipCountFilter.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nimport type { FilterContext, FilterStrategy } from \"../index.js\";\nimport { compareOrderByItems } from \"../orderByComparator.js\";\n\n/**\n * Implements post-fetch filtering for ORDER BY queries to handle continuation tokens correctly.\n * This logic is applied only to the target partition from which a query is resumed.\n * It filters out documents that have already been emitted in previous pages by comparing\n * ORDER BY item values first, then document _rid, and finally using skip count for tie-breaking.\n *\n * Follows the .NET SDK FilterNextAsync logic:\n * 1. Compare OrderBy values with continuation token values\n * 2. Skip documents that come before continuation point\n * 3. For exact OrderBy matches, use RID comparison\n * 4. For exact RID matches, apply skip count logic\n */\nexport class RidSkipCountFilter implements FilterStrategy {\n  private remainingSkipCount: number;\n\n  /**\n   * @param filterContext - The context containing values from the continuation token.\n   */\n  constructor(private readonly filterContext: FilterContext) {\n    this.remainingSkipCount = this.filterContext.skipCount;\n  }\n\n  /**\n   * Applies the comprehensive OrderBy + RID + SkipCount filtering logic.\n   * @param documents - The documents fetched from the target partition.\n   * @returns A new array containing only the documents that should be processed.\n   */\n  public applyFilter(documents: any[]): any[] {\n    const filteredDocs: any[] = [];\n    let skippedCount = 0;\n\n    for (const doc of documents) {\n      if (!this.shouldIncludeDocument(doc)) {\n        skippedCount++;\n        continue;\n      }\n      filteredDocs.push(doc);\n    }\n    return filteredDocs;\n  }\n\n  /**\n   * Determines if a document should be included based on OrderBy values, RID, and skip count.\n   * Implements the .NET SDK's FilterNextAsync logic with robust OrderBy comparison.\n   */\n  private shouldIncludeDocument(doc: any): boolean {\n    // Step 1: OrderBy Value Filtering using OrderByComparator\n    const sortOrderCompare = this.compareOrderByItems(doc);\n\n    // FIXED: Correct the inverted logic!\n    // compareOrderByItems returns: negative if doc < continuation, positive if doc > continuation\n    // But for filtering: negative means doc comes BEFORE (skip), positive means doc comes AFTER (include)\n\n    // If sortOrderCompare < 0, this document comes before the continuation point\n    if (sortOrderCompare < 0) {\n      return true; // Include documents that come after continuation point\n    }\n\n    // If sortOrderCompare > 0, this document comes after the continuation point\n    if (sortOrderCompare > 0) {\n      return false; // Skip documents that come before continuation point\n    }\n\n    // Step 2: RID Filtering (sortOrderCompare === 0, same OrderBy values)\n    // Check if RID is available for comparison (some queries like JOIN may not have RID)\n    // if (!this.filterContext.rid) {\n    //    //   // Without RID, we can't do RID-based filtering, so include the document\n    //   // The skipCount logic will handle any necessary filtering\n    //   if (this.remainingSkipCount > 0) {\n    //    //     this.remainingSkipCount--;\n    //     return false;\n    //   }\n    //    //   return true;\n    // }\n\n    // For ORDER BY queries, _rid is at the top level of doc, not in payload\n    // Query rewrites to: SELECT c._rid, [...] AS orderByItems, {...} AS payload\n    const docRid = doc._rid;\n\n    let ridOrderCompare: number;\n    if (this.filterContext.rid === docRid) {\n      ridOrderCompare = 0;\n    } else {\n      // Use BigInt comparison for accurate RID comparison\n      const continuationBigInt = this.ridToBigInt(this.filterContext.rid);\n      const docBigInt = this.ridToBigInt(docRid);\n\n      if (continuationBigInt < docBigInt) {\n        ridOrderCompare = -1;\n      } else if (continuationBigInt > docBigInt) {\n        ridOrderCompare = 1;\n      } else {\n        ridOrderCompare = 0;\n      }\n    }\n    // Apply direction logic based on sort order and query execution info\n    const sortOrders = this.filterContext.sortOrders || [];\n    const queryExecutionInfo = this.filterContext.queryExecutionInfo;\n\n    // Direction logic based on index scan direction\n    // Find the first descending sort order in the array\n    const hasDescendingSort = sortOrders.some((order) => order === \"Descending\");\n\n    if (!queryExecutionInfo || queryExecutionInfo.reverseRidEnabled) {\n      // Default behavior or when reverseRidEnabled is true\n      if (hasDescendingSort) {\n        ridOrderCompare = -ridOrderCompare; // Flip for DESC sort order\n      }\n    } else {\n      // When reverseRidEnabled is false, use reverseIndexScan\n      if (queryExecutionInfo.reverseIndexScan) {\n        ridOrderCompare = -ridOrderCompare; // Flip based on index scan direction\n      }\n    }\n\n    // if (ridOrderCompare > 0) continue; // Skip\n    if (ridOrderCompare > 0) {\n      return false; // Skip documents that were already processed\n    }\n\n    if (ridOrderCompare < 0) {\n      return true; // Include documents that come after continuation\n    }\n\n    // Step 3: SkipCount Logic (ridOrderCompare === 0, exact same RID)\n    if (this.remainingSkipCount > 0) {\n      this.remainingSkipCount--;\n      return false; // Skip this document due to skip count\n    }\n\n    return true; // Include this document (skip count exhausted)\n  }\n\n  /**\n   * Convert RID to BigInt for accurate comparison.\n   * Decodes base64 RID and extracts the Document ID portion (8 bytes at offset 8) as BigInt.\n   *\n   * RID Structure (from Java SDK ResourceId.java):\n   * - Bytes 0-3: Database ID (4 bytes)\n   * - Bytes 4-7: Collection ID (4 bytes)\n   * - Bytes 8-15: Document ID (8 bytes, stored in Big Endian but compared in Little Endian)\n   * - Bytes 16-19: Attachment ID (4 bytes, optional)\n   */\n  private ridToBigInt(rid: string): bigint {\n    // Validate input RID\n    if (rid === null || rid === undefined) {\n      throw new Error(`RID is null or undefined`);\n    }\n    if (typeof rid !== \"string\") {\n      throw new Error(`RID must be a string, got ${typeof rid}`);\n    }\n    if (rid.trim().length === 0) {\n      throw new Error(`RID is empty string`);\n    }\n\n    try {\n      const normalizedRid = rid.replace(/-/g, \"/\");\n      const bytes = Buffer.from(normalizedRid, \"base64\");\n\n      // Validate RID length - must be at least 16 bytes to contain document ID\n      if (bytes.length < 16) {\n        throw new Error(`RID too short: expected at least 16 bytes, got ${bytes.length}`);\n      }\n\n      // Extract Document ID portion (8 bytes at offset 8-15)\n      // The bytes are stored as Big Endian but must be compared as Little Endian\n      let result = 0n;\n      for (let i = 15; i >= 8; i--) {\n        result = (result << 8n) | BigInt(bytes[i] & 0xff); // & 0xFF treats as unsigned\n      }\n\n      return result;\n    } catch (error) {\n      throw new Error(\n        `Failed to convert RID '${rid}' to BigInt: ${error instanceof Error ? error.message : String(error)}`,\n      );\n    }\n  }\n\n  /**\n   * Compares the OrderBy items of a document with the continuation token's OrderBy items.\n   * Uses the exported compareOrderByItems utility function from orderByItemComparator.\n   * @param doc - The document to compare\n   * @returns negative if doc comes before continuation, 0 if same, positive if doc comes after\n   */\n  private compareOrderByItems(doc: any): number {\n    const docOrderByItems = doc.orderByItems || [];\n    const continuationOrderByItems = this.filterContext.orderByItems || [];\n    const sortOrders = this.filterContext.sortOrders || [];\n\n    // Compare doc vs continuation (not continuation vs doc!)\n    // Returns: negative if doc < continuation, 0 if equal, positive if doc > continuation\n    return compareOrderByItems(docOrderByItems, continuationOrderByItems, sortOrders);\n  }\n}\n"]}
+{
+  "version": 3,
+  "sources": ["/mnt/vss/_work/1/s/sdk/cosmosdb/cosmos/src/queryExecutionContext/queryFilteringStrategy/RidSkipCountFilter.ts"],
+  "sourcesContent": ["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nimport type { FilterContext, FilterStrategy } from \"../index.js\";\nimport { compareOrderByItems } from \"../orderByComparator.js\";\n\n/**\n * Implements post-fetch filtering for ORDER BY queries to handle continuation tokens correctly.\n * This logic is applied only to the target partition from which a query is resumed.\n * It filters out documents that have already been emitted in previous pages by comparing\n * ORDER BY item values first, then document _rid, and finally using skip count for tie-breaking.\n *\n * Follows the .NET SDK FilterNextAsync logic:\n * 1. Compare OrderBy values with continuation token values\n * 2. Skip documents that come before continuation point\n * 3. For exact OrderBy matches, use RID comparison\n * 4. For exact RID matches, apply skip count logic\n */\nexport class RidSkipCountFilter implements FilterStrategy {\n  private remainingSkipCount: number;\n\n  /**\n   * @param filterContext - The context containing values from the continuation token.\n   */\n  constructor(private readonly filterContext: FilterContext) {\n    this.remainingSkipCount = this.filterContext.skipCount;\n  }\n\n  /**\n   * Applies the comprehensive OrderBy + RID + SkipCount filtering logic.\n   * @param documents - The documents fetched from the target partition.\n   * @returns A new array containing only the documents that should be processed.\n   */\n  public applyFilter(documents: any[]): any[] {\n    const filteredDocs: any[] = [];\n    let skippedCount = 0;\n\n    for (const doc of documents) {\n      if (!this.shouldIncludeDocument(doc)) {\n        skippedCount++;\n        continue;\n      }\n      filteredDocs.push(doc);\n    }\n    return filteredDocs;\n  }\n\n  /**\n   * Determines if a document should be included based on OrderBy values, RID, and skip count.\n   * Implements the .NET SDK's FilterNextAsync logic with robust OrderBy comparison.\n   */\n  private shouldIncludeDocument(doc: any): boolean {\n    // Step 1: OrderBy Value Filtering using OrderByComparator\n    const sortOrderCompare = this.compareOrderByItems(doc);\n\n    // FIXED: Correct the inverted logic!\n    // compareOrderByItems returns: negative if doc < continuation, positive if doc > continuation\n    // But for filtering: negative means doc comes BEFORE (skip), positive means doc comes AFTER (include)\n\n    // If sortOrderCompare < 0, this document comes before the continuation point\n    if (sortOrderCompare < 0) {\n      return true; // Include documents that come after continuation point\n    }\n\n    // If sortOrderCompare > 0, this document comes after the continuation point\n    if (sortOrderCompare > 0) {\n      return false; // Skip documents that come before continuation point\n    }\n\n    // Step 2: RID Filtering (sortOrderCompare === 0, same OrderBy values)\n    // Check if RID is available for comparison (some queries like JOIN may not have RID)\n    // if (!this.filterContext.rid) {\n    //    //   // Without RID, we can't do RID-based filtering, so include the document\n    //   // The skipCount logic will handle any necessary filtering\n    //   if (this.remainingSkipCount > 0) {\n    //    //     this.remainingSkipCount--;\n    //     return false;\n    //   }\n    //    //   return true;\n    // }\n\n    // For ORDER BY queries, _rid is at the top level of doc, not in payload\n    // Query rewrites to: SELECT c._rid, [...] AS orderByItems, {...} AS payload\n    const docRid = doc._rid;\n\n    let ridOrderCompare: number;\n    if (this.filterContext.rid === docRid) {\n      ridOrderCompare = 0;\n    } else {\n      // Use BigInt comparison for accurate RID comparison\n      const continuationBigInt = this.ridToBigInt(this.filterContext.rid);\n      const docBigInt = this.ridToBigInt(docRid);\n\n      if (continuationBigInt < docBigInt) {\n        ridOrderCompare = -1;\n      } else if (continuationBigInt > docBigInt) {\n        ridOrderCompare = 1;\n      } else {\n        ridOrderCompare = 0;\n      }\n    }\n    // Apply direction logic based on sort order and query execution info\n    const sortOrders = this.filterContext.sortOrders || [];\n    const queryExecutionInfo = this.filterContext.queryExecutionInfo;\n\n    // Direction logic based on index scan direction\n    // Find the first descending sort order in the array\n    const hasDescendingSort = sortOrders.some((order) => order === \"Descending\");\n\n    if (!queryExecutionInfo || queryExecutionInfo.reverseRidEnabled) {\n      // Default behavior or when reverseRidEnabled is true\n      if (hasDescendingSort) {\n        ridOrderCompare = -ridOrderCompare; // Flip for DESC sort order\n      }\n    } else {\n      // When reverseRidEnabled is false, use reverseIndexScan\n      if (queryExecutionInfo.reverseIndexScan) {\n        ridOrderCompare = -ridOrderCompare; // Flip based on index scan direction\n      }\n    }\n\n    // if (ridOrderCompare > 0) continue; // Skip\n    if (ridOrderCompare > 0) {\n      return false; // Skip documents that were already processed\n    }\n\n    if (ridOrderCompare < 0) {\n      return true; // Include documents that come after continuation\n    }\n\n    // Step 3: SkipCount Logic (ridOrderCompare === 0, exact same RID)\n    if (this.remainingSkipCount > 0) {\n      this.remainingSkipCount--;\n      return false; // Skip this document due to skip count\n    }\n\n    return true; // Include this document (skip count exhausted)\n  }\n\n  /**\n   * Convert RID to BigInt for accurate comparison.\n   * Decodes base64 RID and extracts the Document ID portion (8 bytes at offset 8) as BigInt.\n   *\n   * RID Structure (from Java SDK ResourceId.java):\n   * - Bytes 0-3: Database ID (4 bytes)\n   * - Bytes 4-7: Collection ID (4 bytes)\n   * - Bytes 8-15: Document ID (8 bytes, stored in Big Endian but compared in Little Endian)\n   * - Bytes 16-19: Attachment ID (4 bytes, optional)\n   */\n  private ridToBigInt(rid: string): bigint {\n    // Validate input RID\n    if (rid === null || rid === undefined) {\n      throw new Error(`RID is null or undefined`);\n    }\n    if (typeof rid !== \"string\") {\n      throw new Error(`RID must be a string, got ${typeof rid}`);\n    }\n    if (rid.trim().length === 0) {\n      throw new Error(`RID is empty string`);\n    }\n\n    try {\n      const normalizedRid = rid.replace(/-/g, \"/\");\n      const bytes = Buffer.from(normalizedRid, \"base64\");\n\n      // Validate RID length - must be at least 16 bytes to contain document ID\n      if (bytes.length < 16) {\n        throw new Error(`RID too short: expected at least 16 bytes, got ${bytes.length}`);\n      }\n\n      // Extract Document ID portion (8 bytes at offset 8-15)\n      // The bytes are stored as Big Endian but must be compared as Little Endian\n      let result = 0n;\n      for (let i = 15; i >= 8; i--) {\n        result = (result << 8n) | BigInt(bytes[i] & 0xff); // & 0xFF treats as unsigned\n      }\n\n      return result;\n    } catch (error) {\n      throw new Error(\n        `Failed to convert RID '${rid}' to BigInt: ${error instanceof Error ? error.message : String(error)}`,\n      );\n    }\n  }\n\n  /**\n   * Compares the OrderBy items of a document with the continuation token's OrderBy items.\n   * Uses the exported compareOrderByItems utility function from orderByItemComparator.\n   * @param doc - The document to compare\n   * @returns negative if doc comes before continuation, 0 if same, positive if doc comes after\n   */\n  private compareOrderByItems(doc: any): number {\n    const docOrderByItems = doc.orderByItems || [];\n    const continuationOrderByItems = this.filterContext.orderByItems || [];\n    const sortOrders = this.filterContext.sortOrders || [];\n\n    // Compare doc vs continuation (not continuation vs doc!)\n    // Returns: negative if doc < continuation, 0 if equal, positive if doc > continuation\n    return compareOrderByItems(docOrderByItems, continuationOrderByItems, sortOrders);\n  }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAIA,+BAAoC;AAc7B,MAAM,mBAA6C;AAAA;AAAA;AAAA;AAAA,EAMxD,YAA6B,eAA8B;AAA9B;AAC3B,SAAK,qBAAqB,KAAK,cAAc;AAAA,EAC/C;AAAA,EAPQ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAcD,YAAY,WAAyB;AAC1C,UAAM,eAAsB,CAAC;AAC7B,QAAI,eAAe;AAEnB,eAAW,OAAO,WAAW;AAC3B,UAAI,CAAC,KAAK,sBAAsB,GAAG,GAAG;AACpC;AACA;AAAA,MACF;AACA,mBAAa,KAAK,GAAG;AAAA,IACvB;AACA,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA,EAMQ,sBAAsB,KAAmB;AAE/C,UAAM,mBAAmB,KAAK,oBAAoB,GAAG;AAOrD,QAAI,mBAAmB,GAAG;AACxB,aAAO;AAAA,IACT;AAGA,QAAI,mBAAmB,GAAG;AACxB,aAAO;AAAA,IACT;AAgBA,UAAM,SAAS,IAAI;AAEnB,QAAI;AACJ,QAAI,KAAK,cAAc,QAAQ,QAAQ;AACrC,wBAAkB;AAAA,IACpB,OAAO;AAEL,YAAM,qBAAqB,KAAK,YAAY,KAAK,cAAc,GAAG;AAClE,YAAM,YAAY,KAAK,YAAY,MAAM;AAEzC,UAAI,qBAAqB,WAAW;AAClC,0BAAkB;AAAA,MACpB,WAAW,qBAAqB,WAAW;AACzC,0BAAkB;AAAA,MACpB,OAAO;AACL,0BAAkB;AAAA,MACpB;AAAA,IACF;AAEA,UAAM,aAAa,KAAK,cAAc,cAAc,CAAC;AACrD,UAAM,qBAAqB,KAAK,cAAc;AAI9C,UAAM,oBAAoB,WAAW,KAAK,CAAC,UAAU,UAAU,YAAY;AAE3E,QAAI,CAAC,sBAAsB,mBAAmB,mBAAmB;AAE/D,UAAI,mBAAmB;AACrB,0BAAkB,CAAC;AAAA,MACrB;AAAA,IACF,OAAO;AAEL,UAAI,mBAAmB,kBAAkB;AACvC,0BAAkB,CAAC;AAAA,MACrB;AAAA,IACF;AAGA,QAAI,kBAAkB,GAAG;AACvB,aAAO;AAAA,IACT;AAEA,QAAI,kBAAkB,GAAG;AACvB,aAAO;AAAA,IACT;AAGA,QAAI,KAAK,qBAAqB,GAAG;AAC/B,WAAK;AACL,aAAO;AAAA,IACT;AAEA,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYQ,YAAY,KAAqB;AAEvC,QAAI,QAAQ,QAAQ,QAAQ,QAAW;AACrC,YAAM,IAAI,MAAM,0BAA0B;AAAA,IAC5C;AACA,QAAI,OAAO,QAAQ,UAAU;AAC3B,YAAM,IAAI,MAAM,6BAA6B,OAAO,GAAG,EAAE;AAAA,IAC3D;AACA,QAAI,IAAI,KAAK,EAAE,WAAW,GAAG;AAC3B,YAAM,IAAI,MAAM,qBAAqB;AAAA,IACvC;AAEA,QAAI;AACF,YAAM,gBAAgB,IAAI,QAAQ,MAAM,GAAG;AAC3C,YAAM,QAAQ,OAAO,KAAK,eAAe,QAAQ;AAGjD,UAAI,MAAM,SAAS,IAAI;AACrB,cAAM,IAAI,MAAM,kDAAkD,MAAM,MAAM,EAAE;AAAA,MAClF;AAIA,UAAI,SAAS;AACb,eAAS,IAAI,IAAI,KAAK,GAAG,KAAK;AAC5B,iBAAU,UAAU,KAAM,OAAO,MAAM,CAAC,IAAI,GAAI;AAAA,MAClD;AAEA,aAAO;AAAA,IACT,SAAS,OAAO;AACd,YAAM,IAAI;AAAA,QACR,0BAA0B,GAAG,gBAAgB,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK,CAAC;AAAA,MACrG;AAAA,IACF;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQQ,oBAAoB,KAAkB;AAC5C,UAAM,kBAAkB,IAAI,gBAAgB,CAAC;AAC7C,UAAM,2BAA2B,KAAK,cAAc,gBAAgB,CAAC;AACrE,UAAM,aAAa,KAAK,cAAc,cAAc,CAAC;AAIrD,eAAO,8CAAoB,iBAAiB,0BAA0B,UAAU;AAAA,EAClF;AACF;",
+  "names": []
+}

package/dist/commonjs/queryExecutionContext/queryFilteringStrategy/TargetPartitionRangeManager.js

@@ -1,97 +1,109 @@
-"use strict";
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TargetPartitionRangeManager = exports.QueryExecutionContextType = void 0;
-const ParallelQueryRangeStrategy_js_1 = require("./ParallelQueryRangeStrategy.js");
-const OrderByQueryRangeStrategy_js_1 = require("./OrderByQueryRangeStrategy.js");
-/**
- * Query execution context types
- * @hidden
- */
-var QueryExecutionContextType;
-(function (QueryExecutionContextType) {
-    QueryExecutionContextType["Parallel"] = "Parallel";
-    QueryExecutionContextType["OrderBy"] = "OrderBy";
-})(QueryExecutionContextType || (exports.QueryExecutionContextType = QueryExecutionContextType = {}));
-/**
- * Manager class responsible for filtering target partition ranges based on query type and continuation tokens.
- * Uses the Strategy pattern to provide different filtering logic for different query types.
- * @hidden
- */
+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 TargetPartitionRangeManager_exports = {};
+__export(TargetPartitionRangeManager_exports, {
+  QueryExecutionContextType: () => QueryExecutionContextType,
+  TargetPartitionRangeManager: () => TargetPartitionRangeManager
+});
+module.exports = __toCommonJS(TargetPartitionRangeManager_exports);
+var import_ParallelQueryRangeStrategy = require("./ParallelQueryRangeStrategy.js");
+var import_OrderByQueryRangeStrategy = require("./OrderByQueryRangeStrategy.js");
+var QueryExecutionContextType = /* @__PURE__ */ ((QueryExecutionContextType2) => {
+  QueryExecutionContextType2["Parallel"] = "Parallel";
+  QueryExecutionContextType2["OrderBy"] = "OrderBy";
+  return QueryExecutionContextType2;
+})(QueryExecutionContextType || {});
 class TargetPartitionRangeManager {
-    strategy;
-    config;
-    constructor(config) {
-        this.config = config;
-        this.strategy = this.createStrategy(config);
+  strategy;
+  config;
+  constructor(config) {
+    this.config = config;
+    this.strategy = this.createStrategy(config);
+  }
+  /**
+   * Creates the appropriate strategy based on configuration
+   */
+  createStrategy(config) {
+    if (config.customStrategy) {
+      return config.customStrategy;
     }
-    /**
-     * Creates the appropriate strategy based on configuration
-     */
-    createStrategy(config) {
-        // Use custom strategy if provided
-        if (config.customStrategy) {
-            return config.customStrategy;
-        }
-        // Create default strategy based on query type
-        switch (config.queryType) {
-            case QueryExecutionContextType.Parallel:
-                return new ParallelQueryRangeStrategy_js_1.ParallelQueryRangeStrategy();
-            case QueryExecutionContextType.OrderBy:
-                return new OrderByQueryRangeStrategy_js_1.OrderByQueryRangeStrategy();
-            default:
-                throw new Error(`Unsupported query execution context type: ${config.queryType}`);
-        }
+    switch (config.queryType) {
+      case "Parallel" /* Parallel */:
+        return new import_ParallelQueryRangeStrategy.ParallelQueryRangeStrategy();
+      case "OrderBy" /* OrderBy */:
+        return new import_OrderByQueryRangeStrategy.OrderByQueryRangeStrategy();
+      default:
+        throw new Error(`Unsupported query execution context type: ${config.queryType}`);
     }
-    /**
-     * Filters target partition ranges based on range-token pairs from partition split/merge detection
-     * @param targetRanges - All available target partition ranges (fallback if no range-token pairs)
-     * @param rangeTokenPairs - Pre-processed range-token pairs after split/merge detection
-     * @param additionalQueryInfo - Additional query information to merge with existing queryInfo
-     * @returns Filtered partition ranges and metadata
-     */
-    filterPartitionRanges(targetRanges, rangeTokenPairs, additionalQueryInfo) {
-        // Validate inputs
-        if (!targetRanges || targetRanges.length === 0) {
-            return { rangeTokenPairs: [] };
-        }
-        // Merge base queryInfo with additional queryInfo (additional takes precedence)
-        const mergedQueryInfo = { ...this.config.queryInfo, ...additionalQueryInfo };
-        const result = this.strategy.filterPartitionRanges(targetRanges, rangeTokenPairs, mergedQueryInfo);
-        return result;
-    }
-    /**
-     * Gets the current strategy type
-     */
-    getStrategyType() {
-        return this.strategy.getStrategyType();
-    }
-    /**
-     * Updates the strategy (useful for switching between query types)
-     */
-    updateStrategy(newConfig) {
-        this.config = newConfig;
-        this.strategy = this.createStrategy(newConfig);
-    }
-    /**
-     * Static factory method to create a manager for parallel queries
-     */
-    static createForParallelQuery(queryInfo) {
-        return new TargetPartitionRangeManager({
-            queryType: QueryExecutionContextType.Parallel,
-            queryInfo,
-        });
-    }
-    /**
-     * Static factory method to create a manager for ORDER BY queries
-     */
-    static createForOrderByQuery(queryInfo) {
-        return new TargetPartitionRangeManager({
-            queryType: QueryExecutionContextType.OrderBy,
-            queryInfo,
-        });
+  }
+  /**
+   * Filters target partition ranges based on range-token pairs from partition split/merge detection
+   * @param targetRanges - All available target partition ranges (fallback if no range-token pairs)
+   * @param rangeTokenPairs - Pre-processed range-token pairs after split/merge detection
+   * @param additionalQueryInfo - Additional query information to merge with existing queryInfo
+   * @returns Filtered partition ranges and metadata
+   */
+  filterPartitionRanges(targetRanges, rangeTokenPairs, additionalQueryInfo) {
+    if (!targetRanges || targetRanges.length === 0) {
+      return { rangeTokenPairs: [] };
     }
+    const mergedQueryInfo = { ...this.config.queryInfo, ...additionalQueryInfo };
+    const result = this.strategy.filterPartitionRanges(
+      targetRanges,
+      rangeTokenPairs,
+      mergedQueryInfo
+    );
+    return result;
+  }
+  /**
+   * Gets the current strategy type
+   */
+  getStrategyType() {
+    return this.strategy.getStrategyType();
+  }
+  /**
+   * Updates the strategy (useful for switching between query types)
+   */
+  updateStrategy(newConfig) {
+    this.config = newConfig;
+    this.strategy = this.createStrategy(newConfig);
+  }
+  /**
+   * Static factory method to create a manager for parallel queries
+   */
+  static createForParallelQuery(queryInfo) {
+    return new TargetPartitionRangeManager({
+      queryType: "Parallel" /* Parallel */,
+      queryInfo
+    });
+  }
+  /**
+   * Static factory method to create a manager for ORDER BY queries
+   */
+  static createForOrderByQuery(queryInfo) {
+    return new TargetPartitionRangeManager({
+      queryType: "OrderBy" /* OrderBy */,
+      queryInfo
+    });
+  }
 }
-exports.TargetPartitionRangeManager = TargetPartitionRangeManager;
-//# sourceMappingURL=TargetPartitionRangeManager.js.map
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  QueryExecutionContextType,
+  TargetPartitionRangeManager
+});

package/dist/commonjs/queryExecutionContext/queryFilteringStrategy/TargetPartitionRangeManager.js.map

@@ -1 +1,7 @@
-{"version":3,"file":"TargetPartitionRangeManager.js","sourceRoot":"","sources":["../../../../src/queryExecutionContext/queryFilteringStrategy/TargetPartitionRangeManager.ts"],"names":[],"mappings":";AAAA,uCAAuC;AACvC,kCAAkC;;;AAOlC,mFAA6E;AAC7E,iFAA2E;AAY3E;;;GAGG;AACH,IAAY,yBAGX;AAHD,WAAY,yBAAyB;IACnC,kDAAqB,CAAA;IACrB,gDAAmB,CAAA;AACrB,CAAC,EAHW,yBAAyB,yCAAzB,yBAAyB,QAGpC;AAuBD;;;;GAIG;AACH,MAAa,2BAA2B;IAC9B,QAAQ,CAA+B;IACvC,MAAM,CAAoC;IAElD,YAAY,MAAyC;QACnD,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;IAC9C,CAAC;IAED;;OAEG;IACK,cAAc,CAAC,MAAyC;QAC9D,kCAAkC;QAClC,IAAI,MAAM,CAAC,cAAc,EAAE,CAAC;YAC1B,OAAO,MAAM,CAAC,cAAc,CAAC;QAC/B,CAAC;QAED,8CAA8C;QAC9C,QAAQ,MAAM,CAAC,SAAS,EAAE,CAAC;YACzB,KAAK,yBAAyB,CAAC,QAAQ;gBACrC,OAAO,IAAI,0DAA0B,EAAE,CAAC;YAE1C,KAAK,yBAAyB,CAAC,OAAO;gBACpC,OAAO,IAAI,wDAAyB,EAAE,CAAC;YAEzC;gBACE,MAAM,IAAI,KAAK,CAAC,6CAA6C,MAAM,CAAC,SAAS,EAAE,CAAC,CAAC;QACrF,CAAC;IACH,CAAC;IAED;;;;;;OAMG;IACI,qBAAqB,CAC1B,YAAiC,EACjC,eAAuD,EACvD,mBAA6C;QAE7C,kBAAkB;QAClB,IAAI,CAAC,YAAY,IAAI,YAAY,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC/C,OAAO,EAAE,eAAe,EAAE,EAAE,EAAE,CAAC;QACjC,CAAC;QAED,+EAA+E;QAC/E,MAAM,eAAe,GAAG,EAAE,GAAG,IAAI,CAAC,MAAM,CAAC,SAAS,EAAE,GAAG,mBAAmB,EAAE,CAAC;QAE7E,MAAM,MAAM,GAAG,IAAI,CAAC,QAAQ,CAAC,qBAAqB,CAChD,YAAY,EACZ,eAAe,EACf,eAAe,CAChB,CAAC;QACF,OAAO,MAAM,CAAC;IAChB,CAAC;IAED;;OAEG;IACI,eAAe;QACpB,OAAO,IAAI,CAAC,QAAQ,CAAC,eAAe,EAAE,CAAC;IACzC,CAAC;IAED;;OAEG;IACI,cAAc,CAAC,SAA4C;QAChE,IAAI,CAAC,MAAM,GAAG,SAAS,CAAC;QACxB,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC;IACjD,CAAC;IAED;;OAEG;IACI,MAAM,CAAC,sBAAsB,CAClC,SAAkC;QAElC,OAAO,IAAI,2BAA2B,CAAC;YACrC,SAAS,EAAE,yBAAyB,CAAC,QAAQ;YAC7C,SAAS;SACV,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACI,MAAM,CAAC,qBAAqB,CACjC,SAAkC;QAElC,OAAO,IAAI,2BAA2B,CAAC;YACrC,SAAS,EAAE,yBAAyB,CAAC,OAAO;YAC5C,SAAS;SACV,CAAC,CAAC;IACL,CAAC;CACF;AAjGD,kEAiGC","sourcesContent":["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nimport type { PartitionKeyRange } from \"../../index.js\";\nimport type {\n  TargetPartitionRangeStrategy,\n  PartitionRangeFilterResult,\n} from \"./TargetPartitionRangeStrategy.js\";\nimport { ParallelQueryRangeStrategy } from \"./ParallelQueryRangeStrategy.js\";\nimport { OrderByQueryRangeStrategy } from \"./OrderByQueryRangeStrategy.js\";\n\n/**\n * Interface representing a partition key range with its associated continuation token and filtering condition\n * @hidden\n */\nexport interface PartitionRangeWithContinuationToken {\n  range: PartitionKeyRange;\n  continuationToken?: string;\n  filteringCondition?: string;\n}\n\n/**\n * Query execution context types\n * @hidden\n */\nexport enum QueryExecutionContextType {\n  Parallel = \"Parallel\",\n  OrderBy = \"OrderBy\",\n}\n\n/**\n * Configuration for the Target Partition Range Manager\n * @hidden\n */\nexport interface TargetPartitionRangeManagerConfig {\n  /**\n   * The type of query execution context\n   */\n  queryType: QueryExecutionContextType;\n\n  /**\n   * Additional query information that might be needed for filtering decisions\n   */\n  queryInfo: Record<string, unknown>;\n\n  /**\n   * Custom strategy instance (optional, will use default strategies if not provided)\n   */\n  customStrategy?: TargetPartitionRangeStrategy;\n}\n\n/**\n * Manager class responsible for filtering target partition ranges based on query type and continuation tokens.\n * Uses the Strategy pattern to provide different filtering logic for different query types.\n * @hidden\n */\nexport class TargetPartitionRangeManager {\n  private strategy: TargetPartitionRangeStrategy;\n  private config: TargetPartitionRangeManagerConfig;\n\n  constructor(config: TargetPartitionRangeManagerConfig) {\n    this.config = config;\n    this.strategy = this.createStrategy(config);\n  }\n\n  /**\n   * Creates the appropriate strategy based on configuration\n   */\n  private createStrategy(config: TargetPartitionRangeManagerConfig): TargetPartitionRangeStrategy {\n    // Use custom strategy if provided\n    if (config.customStrategy) {\n      return config.customStrategy;\n    }\n\n    // Create default strategy based on query type\n    switch (config.queryType) {\n      case QueryExecutionContextType.Parallel:\n        return new ParallelQueryRangeStrategy();\n\n      case QueryExecutionContextType.OrderBy:\n        return new OrderByQueryRangeStrategy();\n\n      default:\n        throw new Error(`Unsupported query execution context type: ${config.queryType}`);\n    }\n  }\n\n  /**\n   * Filters target partition ranges based on range-token pairs from partition split/merge detection\n   * @param targetRanges - All available target partition ranges (fallback if no range-token pairs)\n   * @param rangeTokenPairs - Pre-processed range-token pairs after split/merge detection\n   * @param additionalQueryInfo - Additional query information to merge with existing queryInfo\n   * @returns Filtered partition ranges and metadata\n   */\n  public filterPartitionRanges(\n    targetRanges: PartitionKeyRange[],\n    rangeTokenPairs?: PartitionRangeWithContinuationToken[],\n    additionalQueryInfo?: Record<string, unknown>,\n  ): PartitionRangeFilterResult {\n    // Validate inputs\n    if (!targetRanges || targetRanges.length === 0) {\n      return { rangeTokenPairs: [] };\n    }\n\n    // Merge base queryInfo with additional queryInfo (additional takes precedence)\n    const mergedQueryInfo = { ...this.config.queryInfo, ...additionalQueryInfo };\n\n    const result = this.strategy.filterPartitionRanges(\n      targetRanges,\n      rangeTokenPairs,\n      mergedQueryInfo,\n    );\n    return result;\n  }\n\n  /**\n   * Gets the current strategy type\n   */\n  public getStrategyType(): string {\n    return this.strategy.getStrategyType();\n  }\n\n  /**\n   * Updates the strategy (useful for switching between query types)\n   */\n  public updateStrategy(newConfig: TargetPartitionRangeManagerConfig): void {\n    this.config = newConfig;\n    this.strategy = this.createStrategy(newConfig);\n  }\n\n  /**\n   * Static factory method to create a manager for parallel queries\n   */\n  public static createForParallelQuery(\n    queryInfo: Record<string, unknown>,\n  ): TargetPartitionRangeManager {\n    return new TargetPartitionRangeManager({\n      queryType: QueryExecutionContextType.Parallel,\n      queryInfo,\n    });\n  }\n\n  /**\n   * Static factory method to create a manager for ORDER BY queries\n   */\n  public static createForOrderByQuery(\n    queryInfo: Record<string, unknown>,\n  ): TargetPartitionRangeManager {\n    return new TargetPartitionRangeManager({\n      queryType: QueryExecutionContextType.OrderBy,\n      queryInfo,\n    });\n  }\n}\n"]}
+{
+  "version": 3,
+  "sources": ["/mnt/vss/_work/1/s/sdk/cosmosdb/cosmos/src/queryExecutionContext/queryFilteringStrategy/TargetPartitionRangeManager.ts"],
+  "sourcesContent": ["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nimport type { PartitionKeyRange } from \"../../index.js\";\nimport type {\n  TargetPartitionRangeStrategy,\n  PartitionRangeFilterResult,\n} from \"./TargetPartitionRangeStrategy.js\";\nimport { ParallelQueryRangeStrategy } from \"./ParallelQueryRangeStrategy.js\";\nimport { OrderByQueryRangeStrategy } from \"./OrderByQueryRangeStrategy.js\";\n\n/**\n * Interface representing a partition key range with its associated continuation token and filtering condition\n * @hidden\n */\nexport interface PartitionRangeWithContinuationToken {\n  range: PartitionKeyRange;\n  continuationToken?: string;\n  filteringCondition?: string;\n}\n\n/**\n * Query execution context types\n * @hidden\n */\nexport enum QueryExecutionContextType {\n  Parallel = \"Parallel\",\n  OrderBy = \"OrderBy\",\n}\n\n/**\n * Configuration for the Target Partition Range Manager\n * @hidden\n */\nexport interface TargetPartitionRangeManagerConfig {\n  /**\n   * The type of query execution context\n   */\n  queryType: QueryExecutionContextType;\n\n  /**\n   * Additional query information that might be needed for filtering decisions\n   */\n  queryInfo: Record<string, unknown>;\n\n  /**\n   * Custom strategy instance (optional, will use default strategies if not provided)\n   */\n  customStrategy?: TargetPartitionRangeStrategy;\n}\n\n/**\n * Manager class responsible for filtering target partition ranges based on query type and continuation tokens.\n * Uses the Strategy pattern to provide different filtering logic for different query types.\n * @hidden\n */\nexport class TargetPartitionRangeManager {\n  private strategy: TargetPartitionRangeStrategy;\n  private config: TargetPartitionRangeManagerConfig;\n\n  constructor(config: TargetPartitionRangeManagerConfig) {\n    this.config = config;\n    this.strategy = this.createStrategy(config);\n  }\n\n  /**\n   * Creates the appropriate strategy based on configuration\n   */\n  private createStrategy(config: TargetPartitionRangeManagerConfig): TargetPartitionRangeStrategy {\n    // Use custom strategy if provided\n    if (config.customStrategy) {\n      return config.customStrategy;\n    }\n\n    // Create default strategy based on query type\n    switch (config.queryType) {\n      case QueryExecutionContextType.Parallel:\n        return new ParallelQueryRangeStrategy();\n\n      case QueryExecutionContextType.OrderBy:\n        return new OrderByQueryRangeStrategy();\n\n      default:\n        throw new Error(`Unsupported query execution context type: ${config.queryType}`);\n    }\n  }\n\n  /**\n   * Filters target partition ranges based on range-token pairs from partition split/merge detection\n   * @param targetRanges - All available target partition ranges (fallback if no range-token pairs)\n   * @param rangeTokenPairs - Pre-processed range-token pairs after split/merge detection\n   * @param additionalQueryInfo - Additional query information to merge with existing queryInfo\n   * @returns Filtered partition ranges and metadata\n   */\n  public filterPartitionRanges(\n    targetRanges: PartitionKeyRange[],\n    rangeTokenPairs?: PartitionRangeWithContinuationToken[],\n    additionalQueryInfo?: Record<string, unknown>,\n  ): PartitionRangeFilterResult {\n    // Validate inputs\n    if (!targetRanges || targetRanges.length === 0) {\n      return { rangeTokenPairs: [] };\n    }\n\n    // Merge base queryInfo with additional queryInfo (additional takes precedence)\n    const mergedQueryInfo = { ...this.config.queryInfo, ...additionalQueryInfo };\n\n    const result = this.strategy.filterPartitionRanges(\n      targetRanges,\n      rangeTokenPairs,\n      mergedQueryInfo,\n    );\n    return result;\n  }\n\n  /**\n   * Gets the current strategy type\n   */\n  public getStrategyType(): string {\n    return this.strategy.getStrategyType();\n  }\n\n  /**\n   * Updates the strategy (useful for switching between query types)\n   */\n  public updateStrategy(newConfig: TargetPartitionRangeManagerConfig): void {\n    this.config = newConfig;\n    this.strategy = this.createStrategy(newConfig);\n  }\n\n  /**\n   * Static factory method to create a manager for parallel queries\n   */\n  public static createForParallelQuery(\n    queryInfo: Record<string, unknown>,\n  ): TargetPartitionRangeManager {\n    return new TargetPartitionRangeManager({\n      queryType: QueryExecutionContextType.Parallel,\n      queryInfo,\n    });\n  }\n\n  /**\n   * Static factory method to create a manager for ORDER BY queries\n   */\n  public static createForOrderByQuery(\n    queryInfo: Record<string, unknown>,\n  ): TargetPartitionRangeManager {\n    return new TargetPartitionRangeManager({\n      queryType: QueryExecutionContextType.OrderBy,\n      queryInfo,\n    });\n  }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAQA,wCAA2C;AAC3C,uCAA0C;AAgBnC,IAAK,4BAAL,kBAAKA,+BAAL;AACL,EAAAA,2BAAA,cAAW;AACX,EAAAA,2BAAA,aAAU;AAFA,SAAAA;AAAA,GAAA;AA+BL,MAAM,4BAA4B;AAAA,EAC/B;AAAA,EACA;AAAA,EAER,YAAY,QAA2C;AACrD,SAAK,SAAS;AACd,SAAK,WAAW,KAAK,eAAe,MAAM;AAAA,EAC5C;AAAA;AAAA;AAAA;AAAA,EAKQ,eAAe,QAAyE;AAE9F,QAAI,OAAO,gBAAgB;AACzB,aAAO,OAAO;AAAA,IAChB;AAGA,YAAQ,OAAO,WAAW;AAAA,MACxB,KAAK;AACH,eAAO,IAAI,6DAA2B;AAAA,MAExC,KAAK;AACH,eAAO,IAAI,2DAA0B;AAAA,MAEvC;AACE,cAAM,IAAI,MAAM,6CAA6C,OAAO,SAAS,EAAE;AAAA,IACnF;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASO,sBACL,cACA,iBACA,qBAC4B;AAE5B,QAAI,CAAC,gBAAgB,aAAa,WAAW,GAAG;AAC9C,aAAO,EAAE,iBAAiB,CAAC,EAAE;AAAA,IAC/B;AAGA,UAAM,kBAAkB,EAAE,GAAG,KAAK,OAAO,WAAW,GAAG,oBAAoB;AAE3E,UAAM,SAAS,KAAK,SAAS;AAAA,MAC3B;AAAA,MACA;AAAA,MACA;AAAA,IACF;AACA,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKO,kBAA0B;AAC/B,WAAO,KAAK,SAAS,gBAAgB;AAAA,EACvC;AAAA;AAAA;AAAA;AAAA,EAKO,eAAe,WAAoD;AACxE,SAAK,SAAS;AACd,SAAK,WAAW,KAAK,eAAe,SAAS;AAAA,EAC/C;AAAA;AAAA;AAAA;AAAA,EAKA,OAAc,uBACZ,WAC6B;AAC7B,WAAO,IAAI,4BAA4B;AAAA,MACrC,WAAW;AAAA,MACX;AAAA,IACF,CAAC;AAAA,EACH;AAAA;AAAA;AAAA;AAAA,EAKA,OAAc,sBACZ,WAC6B;AAC7B,WAAO,IAAI,4BAA4B;AAAA,MACrC,WAAW;AAAA,MACX;AAAA,IACF,CAAC;AAAA,EACH;AACF;",
+  "names": ["QueryExecutionContextType"]
+}