@azure/cosmos 4.8.0 → 4.9.0

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

@@ -0,0 +1,184 @@
+"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
+ */
+class RidSkipCountFilter {
+    filterContext;
+    remainingSkipCount;
+    /**
+     * @param filterContext - The context containing values from the continuation token.
+     */
+    constructor(filterContext) {
+        this.filterContext = filterContext;
+        this.remainingSkipCount = this.filterContext.skipCount;
+    }
+    /**
+     * 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;
+    }
+    /**
+     * 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)
+    }
+    /**
+     * 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)}`);
+        }
+    }
+    /**
+     * 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);
+    }
+}
+exports.RidSkipCountFilter = RidSkipCountFilter;
+//# sourceMappingURL=RidSkipCountFilter.js.map

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

@@ -0,0 +1 @@
+{"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"]}

package/dist/commonjs/queryExecutionContext/queryFilteringStrategy/TargetPartitionRangeManager.d.ts

@@ -0,0 +1,76 @@
+import type { PartitionKeyRange } from "../../index.js";
+import type { TargetPartitionRangeStrategy, PartitionRangeFilterResult } from "./TargetPartitionRangeStrategy.js";
+/**
+ * Interface representing a partition key range with its associated continuation token and filtering condition
+ * @hidden
+ */
+export interface PartitionRangeWithContinuationToken {
+    range: PartitionKeyRange;
+    continuationToken?: string;
+    filteringCondition?: string;
+}
+/**
+ * Query execution context types
+ * @hidden
+ */
+export declare enum QueryExecutionContextType {
+    Parallel = "Parallel",
+    OrderBy = "OrderBy"
+}
+/**
+ * Configuration for the Target Partition Range Manager
+ * @hidden
+ */
+export interface TargetPartitionRangeManagerConfig {
+    /**
+     * The type of query execution context
+     */
+    queryType: QueryExecutionContextType;
+    /**
+     * Additional query information that might be needed for filtering decisions
+     */
+    queryInfo: Record<string, unknown>;
+    /**
+     * Custom strategy instance (optional, will use default strategies if not provided)
+     */
+    customStrategy?: TargetPartitionRangeStrategy;
+}
+/**
+ * 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
+ */
+export declare class TargetPartitionRangeManager {
+    private strategy;
+    private config;
+    constructor(config: TargetPartitionRangeManagerConfig);
+    /**
+     * Creates the appropriate strategy based on configuration
+     */
+    private createStrategy;
+    /**
+     * 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: PartitionKeyRange[], rangeTokenPairs?: PartitionRangeWithContinuationToken[], additionalQueryInfo?: Record<string, unknown>): PartitionRangeFilterResult;
+    /**
+     * Gets the current strategy type
+     */
+    getStrategyType(): string;
+    /**
+     * Updates the strategy (useful for switching between query types)
+     */
+    updateStrategy(newConfig: TargetPartitionRangeManagerConfig): void;
+    /**
+     * Static factory method to create a manager for parallel queries
+     */
+    static createForParallelQuery(queryInfo: Record<string, unknown>): TargetPartitionRangeManager;
+    /**
+     * Static factory method to create a manager for ORDER BY queries
+     */
+    static createForOrderByQuery(queryInfo: Record<string, unknown>): TargetPartitionRangeManager;
+}
+//# sourceMappingURL=TargetPartitionRangeManager.d.ts.map

package/dist/commonjs/queryExecutionContext/queryFilteringStrategy/TargetPartitionRangeManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TargetPartitionRangeManager.d.ts","sourceRoot":"","sources":["../../../../src/queryExecutionContext/queryFilteringStrategy/TargetPartitionRangeManager.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,KAAK,EACV,4BAA4B,EAC5B,0BAA0B,EAC3B,MAAM,mCAAmC,CAAC;AAI3C;;;GAGG;AACH,MAAM,WAAW,mCAAmC;IAClD,KAAK,EAAE,iBAAiB,CAAC;IACzB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED;;;GAGG;AACH,oBAAY,yBAAyB;IACnC,QAAQ,aAAa;IACrB,OAAO,YAAY;CACpB;AAED;;;GAGG;AACH,MAAM,WAAW,iCAAiC;IAChD;;OAEG;IACH,SAAS,EAAE,yBAAyB,CAAC;IAErC;;OAEG;IACH,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAEnC;;OAEG;IACH,cAAc,CAAC,EAAE,4BAA4B,CAAC;CAC/C;AAED;;;;GAIG;AACH,qBAAa,2BAA2B;IACtC,OAAO,CAAC,QAAQ,CAA+B;IAC/C,OAAO,CAAC,MAAM,CAAoC;gBAEtC,MAAM,EAAE,iCAAiC;IAKrD;;OAEG;IACH,OAAO,CAAC,cAAc;IAmBtB;;;;;;OAMG;IACI,qBAAqB,CAC1B,YAAY,EAAE,iBAAiB,EAAE,EACjC,eAAe,CAAC,EAAE,mCAAmC,EAAE,EACvD,mBAAmB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC5C,0BAA0B;IAiB7B;;OAEG;IACI,eAAe,IAAI,MAAM;IAIhC;;OAEG;IACI,cAAc,CAAC,SAAS,EAAE,iCAAiC,GAAG,IAAI;IAKzE;;OAEG;WACW,sBAAsB,CAClC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACjC,2BAA2B;IAO9B;;OAEG;WACW,qBAAqB,CACjC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACjC,2BAA2B;CAM/B"}

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

@@ -0,0 +1,97 @@
+"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
+ */
+class TargetPartitionRangeManager {
+    strategy;
+    config;
+    constructor(config) {
+        this.config = config;
+        this.strategy = this.createStrategy(config);
+    }
+    /**
+     * 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}`);
+        }
+    }
+    /**
+     * 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,
+        });
+    }
+}
+exports.TargetPartitionRangeManager = TargetPartitionRangeManager;
+//# sourceMappingURL=TargetPartitionRangeManager.js.map

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

@@ -0,0 +1 @@
+{"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"]}

package/dist/commonjs/queryExecutionContext/queryFilteringStrategy/TargetPartitionRangeStrategy.d.ts

@@ -0,0 +1,30 @@
+import type { PartitionKeyRange } from "../../index.js";
+import type { PartitionRangeWithContinuationToken } from "./TargetPartitionRangeManager.js";
+/**
+ * Represents the result of partition range filtering
+ * @hidden
+ */
+export interface PartitionRangeFilterResult {
+    /**
+     * The filtered partition ranges with their associated continuation tokens and filtering conditions
+     */
+    rangeTokenPairs: PartitionRangeWithContinuationToken[];
+}
+/**
+ * Strategy interface for filtering target partition ranges based on query type and continuation token
+ * @hidden
+ */
+export interface TargetPartitionRangeStrategy {
+    /**
+     * Gets the strategy type identifier
+     */
+    getStrategyType(): string;
+    /**
+     * Filters target partition ranges based on the continuation token and query-specific logic
+     * @param targetRanges - All available target partition ranges
+     * @param continuationToken - The continuation token to resume from (if any)
+     * @returns Filtered partition ranges and metadata
+     */
+    filterPartitionRanges(targetRanges: PartitionKeyRange[], continuationRanges?: PartitionRangeWithContinuationToken[], queryInfo?: Record<string, unknown>): PartitionRangeFilterResult;
+}
+//# sourceMappingURL=TargetPartitionRangeStrategy.d.ts.map

package/dist/commonjs/queryExecutionContext/queryFilteringStrategy/TargetPartitionRangeStrategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TargetPartitionRangeStrategy.d.ts","sourceRoot":"","sources":["../../../../src/queryExecutionContext/queryFilteringStrategy/TargetPartitionRangeStrategy.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,KAAK,EAAE,mCAAmC,EAAE,MAAM,kCAAkC,CAAC;AAE5F;;;GAGG;AACH,MAAM,WAAW,0BAA0B;IACzC;;OAEG;IACH,eAAe,EAAE,mCAAmC,EAAE,CAAC;CACxD;AAED;;;GAGG;AACH,MAAM,WAAW,4BAA4B;IAC3C;;OAEG;IACH,eAAe,IAAI,MAAM,CAAC;IAE1B;;;;;OAKG;IACH,qBAAqB,CACnB,YAAY,EAAE,iBAAiB,EAAE,EACjC,kBAAkB,CAAC,EAAE,mCAAmC,EAAE,EAC1D,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAClC,0BAA0B,CAAC;CAC/B"}

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

@@ -0,0 +1,5 @@
+"use strict";
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=TargetPartitionRangeStrategy.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TargetPartitionRangeStrategy.js","sourceRoot":"","sources":["../../../../src/queryExecutionContext/queryFilteringStrategy/TargetPartitionRangeStrategy.ts"],"names":[],"mappings":";AAAA,uCAAuC;AACvC,kCAAkC","sourcesContent":["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nimport type { PartitionKeyRange } from \"../../index.js\";\nimport type { PartitionRangeWithContinuationToken } from \"./TargetPartitionRangeManager.js\";\n\n/**\n * Represents the result of partition range filtering\n * @hidden\n */\nexport interface PartitionRangeFilterResult {\n  /**\n   * The filtered partition ranges with their associated continuation tokens and filtering conditions\n   */\n  rangeTokenPairs: PartitionRangeWithContinuationToken[];\n}\n\n/**\n * Strategy interface for filtering target partition ranges based on query type and continuation token\n * @hidden\n */\nexport interface TargetPartitionRangeStrategy {\n  /**\n   * Gets the strategy type identifier\n   */\n  getStrategyType(): string;\n\n  /**\n   * Filters target partition ranges based on the continuation token and query-specific logic\n   * @param targetRanges - All available target partition ranges\n   * @param continuationToken - The continuation token to resume from (if any)\n   * @returns Filtered partition ranges and metadata\n   */\n  filterPartitionRanges(\n    targetRanges: PartitionKeyRange[],\n    continuationRanges?: PartitionRangeWithContinuationToken[],\n    queryInfo?: Record<string, unknown>,\n  ): PartitionRangeFilterResult;\n}\n"]}

package/dist/commonjs/queryExecutionContext/queryProcessingStrategy/OrderByQueryProcessingStrategy.d.ts

@@ -0,0 +1,29 @@
+import type { OrderByQueryContinuationToken } from "../../documents/ContinuationToken/OrderByQueryContinuationToken.js";
+import type { CompositeQueryContinuationToken } from "../../documents/ContinuationToken/CompositeQueryContinuationToken.js";
+import type { FilterContext } from "../queryFilteringStrategy/FilterStrategy.js";
+import type { QueryProcessingStrategy } from "./QueryProcessingStrategy.js";
+/**
+ * Strategy for processing ORDER BY queries
+ * @hidden
+ */
+export declare class OrderByQueryProcessingStrategy implements QueryProcessingStrategy {
+    private readonly sortOrders;
+    constructor(sortOrders: any[]);
+    /**
+     * Creates additional query info from ORDER BY continuation token
+     */
+    createAdditionalQueryInfo(parsedToken: OrderByQueryContinuationToken | CompositeQueryContinuationToken): any;
+    /**
+     * Creates filter context for ORDER BY continuation token processing
+     */
+    createFilterContext(parsedToken: OrderByQueryContinuationToken | CompositeQueryContinuationToken): FilterContext | undefined;
+    /**
+     * For ORDER BY queries, only apply filter to the target partition (last range in continuation)
+     */
+    getPartitionFilterContext(filterContext: FilterContext | undefined, targetPartitionId: string | undefined, partitionTargetRangeId: string): FilterContext | undefined;
+    /**
+     * Parses ORDER BY continuation token
+     */
+    parseContinuationToken(continuationToken: string): OrderByQueryContinuationToken | CompositeQueryContinuationToken;
+}
+//# sourceMappingURL=OrderByQueryProcessingStrategy.d.ts.map

package/dist/commonjs/queryExecutionContext/queryProcessingStrategy/OrderByQueryProcessingStrategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OrderByQueryProcessingStrategy.d.ts","sourceRoot":"","sources":["../../../../src/queryExecutionContext/queryProcessingStrategy/OrderByQueryProcessingStrategy.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,oEAAoE,CAAC;AAExH,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,sEAAsE,CAAC;AAC5H,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6CAA6C,CAAC;AACjF,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AAE5E;;;GAGG;AACH,qBAAa,8BAA+B,YAAW,uBAAuB;IAChE,OAAO,CAAC,QAAQ,CAAC,UAAU;gBAAV,UAAU,EAAE,GAAG,EAAE;IAC9C;;OAEG;IACH,yBAAyB,CACvB,WAAW,EAAE,6BAA6B,GAAG,+BAA+B,GAC3E,GAAG;IAQN;;OAEG;IACH,mBAAmB,CACjB,WAAW,EAAE,6BAA6B,GAAG,+BAA+B,GAC3E,aAAa,GAAG,SAAS;IAU5B;;OAEG;IACH,yBAAyB,CACvB,aAAa,EAAE,aAAa,GAAG,SAAS,EACxC,iBAAiB,EAAE,MAAM,GAAG,SAAS,EACrC,sBAAsB,EAAE,MAAM,GAC7B,aAAa,GAAG,SAAS;IAM5B;;OAEG;IACH,sBAAsB,CACpB,iBAAiB,EAAE,MAAM,GACxB,6BAA6B,GAAG,+BAA+B;CAGnE"}

package/dist/commonjs/queryExecutionContext/queryProcessingStrategy/OrderByQueryProcessingStrategy.js

@@ -0,0 +1,57 @@
+"use strict";
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrderByQueryProcessingStrategy = void 0;
+const OrderByQueryContinuationToken_js_1 = require("../../documents/ContinuationToken/OrderByQueryContinuationToken.js");
+/**
+ * Strategy for processing ORDER BY queries
+ * @hidden
+ */
+class OrderByQueryProcessingStrategy {
+    sortOrders;
+    constructor(sortOrders) {
+        this.sortOrders = sortOrders;
+    }
+    /**
+     * Creates additional query info from ORDER BY continuation token
+     */
+    createAdditionalQueryInfo(parsedToken) {
+        const orderByToken = parsedToken;
+        const info = {};
+        if (orderByToken.orderByItems)
+            info.orderByItems = orderByToken.orderByItems;
+        if (orderByToken.documentRid)
+            info.rid = orderByToken.documentRid;
+        return Object.keys(info).length > 0 ? info : undefined;
+    }
+    /**
+     * Creates filter context for ORDER BY continuation token processing
+     */
+    createFilterContext(parsedToken) {
+        const orderByToken = parsedToken;
+        return {
+            orderByItems: orderByToken.orderByItems,
+            rid: orderByToken.documentRid,
+            skipCount: orderByToken.skipCount,
+            sortOrders: this.sortOrders,
+        };
+    }
+    /**
+     * For ORDER BY queries, only apply filter to the target partition (last range in continuation)
+     */
+    getPartitionFilterContext(filterContext, targetPartitionId, partitionTargetRangeId) {
+        if (!filterContext)
+            return undefined;
+        const isTargetPartition = targetPartitionId === partitionTargetRangeId;
+        return isTargetPartition ? filterContext : undefined;
+    }
+    /**
+     * Parses ORDER BY continuation token
+     */
+    parseContinuationToken(continuationToken) {
+        return (0, OrderByQueryContinuationToken_js_1.parseOrderByQueryContinuationToken)(continuationToken);
+    }
+}
+exports.OrderByQueryProcessingStrategy = OrderByQueryProcessingStrategy;
+//# sourceMappingURL=OrderByQueryProcessingStrategy.js.map

package/dist/commonjs/queryExecutionContext/queryProcessingStrategy/OrderByQueryProcessingStrategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"OrderByQueryProcessingStrategy.js","sourceRoot":"","sources":["../../../../src/queryExecutionContext/queryProcessingStrategy/OrderByQueryProcessingStrategy.ts"],"names":[],"mappings":";AAAA,uCAAuC;AACvC,kCAAkC;;;AAGlC,yHAAwH;AAKxH;;;GAGG;AACH,MAAa,8BAA8B;IACZ;IAA7B,YAA6B,UAAiB;QAAjB,eAAU,GAAV,UAAU,CAAO;IAAG,CAAC;IAClD;;OAEG;IACH,yBAAyB,CACvB,WAA4E;QAE5E,MAAM,YAAY,GAAG,WAA4C,CAAC;QAClE,MAAM,IAAI,GAAQ,EAAE,CAAC;QACrB,IAAI,YAAY,CAAC,YAAY;YAAE,IAAI,CAAC,YAAY,GAAG,YAAY,CAAC,YAAY,CAAC;QAC7E,IAAI,YAAY,CAAC,WAAW;YAAE,IAAI,CAAC,GAAG,GAAG,YAAY,CAAC,WAAW,CAAC;QAClE,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC;IACzD,CAAC;IAED;;OAEG;IACH,mBAAmB,CACjB,WAA4E;QAE5E,MAAM,YAAY,GAAG,WAA4C,CAAC;QAClE,OAAO;YACL,YAAY,EAAE,YAAY,CAAC,YAAY;YACvC,GAAG,EAAE,YAAY,CAAC,WAAW;YAC7B,SAAS,EAAE,YAAY,CAAC,SAAS;YACjC,UAAU,EAAE,IAAI,CAAC,UAAU;SAC5B,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,yBAAyB,CACvB,aAAwC,EACxC,iBAAqC,EACrC,sBAA8B;QAE9B,IAAI,CAAC,aAAa;YAAE,OAAO,SAAS,CAAC;QACrC,MAAM,iBAAiB,GAAG,iBAAiB,KAAK,sBAAsB,CAAC;QACvE,OAAO,iBAAiB,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,SAAS,CAAC;IACvD,CAAC;IAED;;OAEG;IACH,sBAAsB,CACpB,iBAAyB;QAEzB,OAAO,IAAA,qEAAkC,EAAC,iBAAiB,CAAC,CAAC;IAC/D,CAAC;CACF;AAnDD,wEAmDC","sourcesContent":["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nimport type { OrderByQueryContinuationToken } from \"../../documents/ContinuationToken/OrderByQueryContinuationToken.js\";\nimport { parseOrderByQueryContinuationToken } from \"../../documents/ContinuationToken/OrderByQueryContinuationToken.js\";\nimport type { CompositeQueryContinuationToken } from \"../../documents/ContinuationToken/CompositeQueryContinuationToken.js\";\nimport type { FilterContext } from \"../queryFilteringStrategy/FilterStrategy.js\";\nimport type { QueryProcessingStrategy } from \"./QueryProcessingStrategy.js\";\n\n/**\n * Strategy for processing ORDER BY queries\n * @hidden\n */\nexport class OrderByQueryProcessingStrategy implements QueryProcessingStrategy {\n  constructor(private readonly sortOrders: any[]) {}\n  /**\n   * Creates additional query info from ORDER BY continuation token\n   */\n  createAdditionalQueryInfo(\n    parsedToken: OrderByQueryContinuationToken | CompositeQueryContinuationToken,\n  ): any {\n    const orderByToken = parsedToken as OrderByQueryContinuationToken;\n    const info: any = {};\n    if (orderByToken.orderByItems) info.orderByItems = orderByToken.orderByItems;\n    if (orderByToken.documentRid) info.rid = orderByToken.documentRid;\n    return Object.keys(info).length > 0 ? info : undefined;\n  }\n\n  /**\n   * Creates filter context for ORDER BY continuation token processing\n   */\n  createFilterContext(\n    parsedToken: OrderByQueryContinuationToken | CompositeQueryContinuationToken,\n  ): FilterContext | undefined {\n    const orderByToken = parsedToken as OrderByQueryContinuationToken;\n    return {\n      orderByItems: orderByToken.orderByItems,\n      rid: orderByToken.documentRid,\n      skipCount: orderByToken.skipCount,\n      sortOrders: this.sortOrders,\n    };\n  }\n\n  /**\n   * For ORDER BY queries, only apply filter to the target partition (last range in continuation)\n   */\n  getPartitionFilterContext(\n    filterContext: FilterContext | undefined,\n    targetPartitionId: string | undefined,\n    partitionTargetRangeId: string,\n  ): FilterContext | undefined {\n    if (!filterContext) return undefined;\n    const isTargetPartition = targetPartitionId === partitionTargetRangeId;\n    return isTargetPartition ? filterContext : undefined;\n  }\n\n  /**\n   * Parses ORDER BY continuation token\n   */\n  parseContinuationToken(\n    continuationToken: string,\n  ): OrderByQueryContinuationToken | CompositeQueryContinuationToken {\n    return parseOrderByQueryContinuationToken(continuationToken);\n  }\n}\n"]}

package/dist/commonjs/queryExecutionContext/queryProcessingStrategy/ParallelQueryProcessingStrategy.d.ts

@@ -0,0 +1,27 @@
+import type { OrderByQueryContinuationToken } from "../../documents/ContinuationToken/OrderByQueryContinuationToken.js";
+import type { CompositeQueryContinuationToken } from "../../documents/ContinuationToken/CompositeQueryContinuationToken.js";
+import type { FilterContext } from "../queryFilteringStrategy/FilterStrategy.js";
+import type { QueryProcessingStrategy } from "./QueryProcessingStrategy.js";
+/**
+ * Strategy for processing parallel queries (non-ORDER BY)
+ * @hidden
+ */
+export declare class ParallelQueryProcessingStrategy implements QueryProcessingStrategy {
+    /**
+     * Parallel queries don't need additional query info from continuation token
+     */
+    createAdditionalQueryInfo(_parsedToken: OrderByQueryContinuationToken | CompositeQueryContinuationToken): any;
+    /**
+     * Parallel queries don't use filter context for continuation token processing
+     */
+    createFilterContext(_parsedToken: OrderByQueryContinuationToken | CompositeQueryContinuationToken): FilterContext | undefined;
+    /**
+     * Parallel queries don't apply partition-specific filter context
+     */
+    getPartitionFilterContext(_filterContext: FilterContext | undefined, _targetPartitionId: string | undefined, _partitionTargetRangeId: string): FilterContext | undefined;
+    /**
+     * Parses parallel/composite continuation token
+     */
+    parseContinuationToken(continuationToken: string): OrderByQueryContinuationToken | CompositeQueryContinuationToken;
+}
+//# sourceMappingURL=ParallelQueryProcessingStrategy.d.ts.map

package/dist/commonjs/queryExecutionContext/queryProcessingStrategy/ParallelQueryProcessingStrategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ParallelQueryProcessingStrategy.d.ts","sourceRoot":"","sources":["../../../../src/queryExecutionContext/queryProcessingStrategy/ParallelQueryProcessingStrategy.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,oEAAoE,CAAC;AACxH,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,sEAAsE,CAAC;AAE5H,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6CAA6C,CAAC;AACjF,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AAE5E;;;GAGG;AACH,qBAAa,+BAAgC,YAAW,uBAAuB;IAC7E;;OAEG;IACH,yBAAyB,CACvB,YAAY,EAAE,6BAA6B,GAAG,+BAA+B,GAC5E,GAAG;IAIN;;OAEG;IACH,mBAAmB,CACjB,YAAY,EAAE,6BAA6B,GAAG,+BAA+B,GAC5E,aAAa,GAAG,SAAS;IAI5B;;OAEG;IACH,yBAAyB,CACvB,cAAc,EAAE,aAAa,GAAG,SAAS,EACzC,kBAAkB,EAAE,MAAM,GAAG,SAAS,EACtC,uBAAuB,EAAE,MAAM,GAC9B,aAAa,GAAG,SAAS;IAI5B;;OAEG;IACH,sBAAsB,CACpB,iBAAiB,EAAE,MAAM,GACxB,6BAA6B,GAAG,+BAA+B;CAGnE"}

package/dist/commonjs/queryExecutionContext/queryProcessingStrategy/ParallelQueryProcessingStrategy.js

@@ -0,0 +1,38 @@
+"use strict";
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParallelQueryProcessingStrategy = void 0;
+const CompositeQueryContinuationToken_js_1 = require("../../documents/ContinuationToken/CompositeQueryContinuationToken.js");
+/**
+ * Strategy for processing parallel queries (non-ORDER BY)
+ * @hidden
+ */
+class ParallelQueryProcessingStrategy {
+    /**
+     * Parallel queries don't need additional query info from continuation token
+     */
+    createAdditionalQueryInfo(_parsedToken) {
+        return undefined;
+    }
+    /**
+     * Parallel queries don't use filter context for continuation token processing
+     */
+    createFilterContext(_parsedToken) {
+        return undefined;
+    }
+    /**
+     * Parallel queries don't apply partition-specific filter context
+     */
+    getPartitionFilterContext(_filterContext, _targetPartitionId, _partitionTargetRangeId) {
+        return undefined;
+    }
+    /**
+     * Parses parallel/composite continuation token
+     */
+    parseContinuationToken(continuationToken) {
+        return (0, CompositeQueryContinuationToken_js_1.parseCompositeQueryContinuationToken)(continuationToken);
+    }
+}
+exports.ParallelQueryProcessingStrategy = ParallelQueryProcessingStrategy;
+//# sourceMappingURL=ParallelQueryProcessingStrategy.js.map

package/dist/commonjs/queryExecutionContext/queryProcessingStrategy/ParallelQueryProcessingStrategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ParallelQueryProcessingStrategy.js","sourceRoot":"","sources":["../../../../src/queryExecutionContext/queryProcessingStrategy/ParallelQueryProcessingStrategy.ts"],"names":[],"mappings":";AAAA,uCAAuC;AACvC,kCAAkC;;;AAIlC,6HAA4H;AAI5H;;;GAGG;AACH,MAAa,+BAA+B;IAC1C;;OAEG;IACH,yBAAyB,CACvB,YAA6E;QAE7E,OAAO,SAAS,CAAC;IACnB,CAAC;IAED;;OAEG;IACH,mBAAmB,CACjB,YAA6E;QAE7E,OAAO,SAAS,CAAC;IACnB,CAAC;IAED;;OAEG;IACH,yBAAyB,CACvB,cAAyC,EACzC,kBAAsC,EACtC,uBAA+B;QAE/B,OAAO,SAAS,CAAC;IACnB,CAAC;IAED;;OAEG;IACH,sBAAsB,CACpB,iBAAyB;QAEzB,OAAO,IAAA,yEAAoC,EAAC,iBAAiB,CAAC,CAAC;IACjE,CAAC;CACF;AAtCD,0EAsCC","sourcesContent":["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nimport type { OrderByQueryContinuationToken } from \"../../documents/ContinuationToken/OrderByQueryContinuationToken.js\";\nimport type { CompositeQueryContinuationToken } from \"../../documents/ContinuationToken/CompositeQueryContinuationToken.js\";\nimport { parseCompositeQueryContinuationToken } from \"../../documents/ContinuationToken/CompositeQueryContinuationToken.js\";\nimport type { FilterContext } from \"../queryFilteringStrategy/FilterStrategy.js\";\nimport type { QueryProcessingStrategy } from \"./QueryProcessingStrategy.js\";\n\n/**\n * Strategy for processing parallel queries (non-ORDER BY)\n * @hidden\n */\nexport class ParallelQueryProcessingStrategy implements QueryProcessingStrategy {\n  /**\n   * Parallel queries don't need additional query info from continuation token\n   */\n  createAdditionalQueryInfo(\n    _parsedToken: OrderByQueryContinuationToken | CompositeQueryContinuationToken,\n  ): any {\n    return undefined;\n  }\n\n  /**\n   * Parallel queries don't use filter context for continuation token processing\n   */\n  createFilterContext(\n    _parsedToken: OrderByQueryContinuationToken | CompositeQueryContinuationToken,\n  ): FilterContext | undefined {\n    return undefined;\n  }\n\n  /**\n   * Parallel queries don't apply partition-specific filter context\n   */\n  getPartitionFilterContext(\n    _filterContext: FilterContext | undefined,\n    _targetPartitionId: string | undefined,\n    _partitionTargetRangeId: string,\n  ): FilterContext | undefined {\n    return undefined;\n  }\n\n  /**\n   * Parses parallel/composite continuation token\n   */\n  parseContinuationToken(\n    continuationToken: string,\n  ): OrderByQueryContinuationToken | CompositeQueryContinuationToken {\n    return parseCompositeQueryContinuationToken(continuationToken);\n  }\n}\n"]}