@azure/cosmos 4.9.1 → 4.9.3

package/dist/commonjs/queryExecutionContext/PartitionRangeManager.js.map

@@ -1 +1,7 @@
-{"version":3,"file":"PartitionRangeManager.js","sourceRoot":"","sources":["../../../src/queryExecutionContext/PartitionRangeManager.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nimport { QueryRangeWithContinuationToken } from \"../documents/ContinuationToken/CompositeQueryContinuationToken.js\";\nimport type { QueryRangeMapping } from \"./queryRangeMapping.js\";\n\n/**\n * Manages partition key range mappings for query execution.\n * Handles range operations, offset/limit processing, and distinct query logic.\n * @hidden\n */\nexport class PartitionRangeManager {\n  private partitionKeyRangeMap: Map<string, QueryRangeMapping> = new Map();\n\n  constructor(initialPartitionKeyRangeMap?: Map<string, QueryRangeMapping>) {\n    if (initialPartitionKeyRangeMap) {\n      this.partitionKeyRangeMap = new Map(initialPartitionKeyRangeMap);\n    }\n  }\n\n  /**\n   * Gets a copy of the current partition key range map for constructor pattern\n   */\n  public getPartitionKeyRangeMap(): Map<string, QueryRangeMapping> {\n    return new Map(this.partitionKeyRangeMap);\n  }\n\n  /**\n   * Checks if a continuation token indicates an exhausted partition\n   * @param continuationToken - The continuation token to check\n   * @returns true if the partition is exhausted (null, empty, or \"null\" string)\n   */\n  private isPartitionExhausted(continuationToken: string | undefined): boolean {\n    return (\n      !continuationToken ||\n      continuationToken === \"\" ||\n      continuationToken === \"null\" ||\n      continuationToken.toLowerCase() === \"null\"\n    );\n  }\n\n  /**\n   * Adds a range mapping to the partition key range map\n   * Does not allow updates to existing keys - only new additions\n   * @param rangeId - Unique identifier for the partition range\n   * @param mapping - The QueryRangeMapping to add\n   */\n  private addPartitionRangeMapping(rangeId: string, mapping: QueryRangeMapping): void {\n    if (!this.partitionKeyRangeMap.has(rangeId)) {\n      this.partitionKeyRangeMap.set(rangeId, mapping);\n    }\n  }\n\n  /**\n   * Removes a range mapping from the partition key range map\n   */\n  public removePartitionRangeMapping(rangeId: string): void {\n    this.partitionKeyRangeMap.delete(rangeId);\n  }\n\n  /**\n   * Updates the partition key range map with new mappings from the endpoint response\n   * @param partitionKeyRangeMap - Map of range IDs to QueryRangeMapping objects\n   */\n  public addPartitionKeyRangeMap(partitionKeyRangeMap: Map<string, QueryRangeMapping>): void {\n    if (partitionKeyRangeMap) {\n      for (const [rangeId, mapping] of partitionKeyRangeMap) {\n        this.addPartitionRangeMapping(rangeId, mapping);\n      }\n    }\n  }\n\n  /**\n   * Checks if there are any unprocessed ranges in the sliding window\n   */\n  public hasUnprocessedRanges(): boolean {\n    return this.partitionKeyRangeMap.size > 0;\n  }\n\n  /**\n   * Removes exhausted(fully drained) ranges from the given range mappings\n   * @param rangeMappings - Array of range mappings to filter\n   * @returns Filtered array without exhausted ranges\n   */\n  public removeExhaustedRanges(rangeMappings: QueryRangeMapping[]): QueryRangeMapping[] {\n    if (!rangeMappings || !Array.isArray(rangeMappings)) {\n      return [];\n    }\n\n    return rangeMappings.filter((mapping) => {\n      if (!mapping) {\n        return false;\n      }\n      const isExhausted = this.isPartitionExhausted(mapping.continuationToken);\n\n      if (isExhausted) {\n        return false;\n      }\n      return true;\n    });\n  }\n\n  /**\n   * Processes ranges for ORDER BY queries\n   */\n  public processOrderByRanges(pageSize: number): {\n    endIndex: number;\n    processedRanges: string[];\n    lastRangeBeforePageLimit: QueryRangeMapping | null;\n  } {\n    let endIndex = 0;\n    const processedRanges: string[] = [];\n    let lastRangeBeforePageLimit: QueryRangeMapping | null = null;\n    let rangeIndex = 0;\n    for (const [rangeId, value] of this.partitionKeyRangeMap) {\n      rangeIndex++;\n      const { itemCount } = value;\n      // Check if this complete range fits within remaining page size capacity\n      if (endIndex + itemCount <= pageSize) {\n        lastRangeBeforePageLimit = value;\n        endIndex += itemCount;\n        processedRanges.push(rangeId);\n      } else {\n        break;\n      }\n    }\n\n    return { endIndex, processedRanges, lastRangeBeforePageLimit };\n  }\n\n  public processEmptyOrderByRanges(ranges: QueryRangeWithContinuationToken[]): {\n    endIndex: number;\n    processedRanges: string[];\n    lastRangeBeforePageLimit: QueryRangeMapping | undefined;\n  } {\n    const endIndex = 0;\n    const processedRanges: string[] = [];\n    let lastRangeBeforePageLimit: QueryRangeMapping | undefined;\n\n    // since there is no data returned add all the ids to processed ranges\n    for (const [rangeId, _] of this.partitionKeyRangeMap) {\n      processedRanges.push(rangeId);\n    }\n    // search for matching range in the map(min max value exact match) and return that as lastRangeBeforePageLimit\n    for (const [_, mapping] of this.partitionKeyRangeMap) {\n      if (\n        mapping.partitionKeyRange!.minInclusive === ranges[0].queryRange.min &&\n        mapping.partitionKeyRange!.maxExclusive === ranges[0].queryRange.max\n      ) {\n        lastRangeBeforePageLimit = mapping;\n        break;\n      }\n    }\n\n    return { endIndex, processedRanges, lastRangeBeforePageLimit };\n  }\n  /**\n   * Processes ranges for parallel queries - multi-range aggregation\n   */\n  public processParallelRanges(pageSize: number): {\n    endIndex: number;\n    processedRanges: string[];\n    processedRangeMappings: QueryRangeMapping[];\n    lastPartitionBeforeCutoff?: { rangeId: string; mapping: QueryRangeMapping };\n  } {\n    let endIndex = 0;\n    const processedRanges: string[] = [];\n    const processedRangeMappings: QueryRangeMapping[] = [];\n    let rangesAggregatedInCurrentToken = 0;\n    let lastPartitionBeforeCutoff: { rangeId: string; mapping: QueryRangeMapping } | undefined;\n\n    for (const [rangeId, value] of this.partitionKeyRangeMap) {\n      rangesAggregatedInCurrentToken++;\n\n      // Validate range data\n      if (!value || value.itemCount === undefined) {\n        continue;\n      }\n\n      const { itemCount } = value;\n\n      // ASSUMPTION: Backend should respect maxItemCount and return pageSize or fewer items per partition.\n      // The logic below expects itemCount (items from a partition) to be <= pageSize.\n      // KNOWN ISSUE: Backend currently violates this contract for non-streaming queries (e.g., hybrid queries),\n      // returning more items per partition than maxItemCount specified. This causes pagination logic to fail,\n      // as ranges with itemCount > pageSize cannot fit and result in endIndex=0.\n      if (endIndex + itemCount <= pageSize) {\n        lastPartitionBeforeCutoff = { rangeId, mapping: value };\n        endIndex += itemCount;\n        processedRanges.push(rangeId);\n        processedRangeMappings.push(value);\n      } else {\n        break; // No more ranges can fit, exit loop\n      }\n    }\n\n    return { endIndex, processedRanges, processedRangeMappings, lastPartitionBeforeCutoff };\n  }\n}\n"]}
+{
+  "version": 3,
+  "sources": ["../../../src/queryExecutionContext/PartitionRangeManager.ts"],
+  "sourcesContent": ["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nimport type { QueryRangeWithContinuationToken } from \"../documents/ContinuationToken/CompositeQueryContinuationToken.js\";\nimport type { QueryRangeMapping } from \"./queryRangeMapping.js\";\n\n/**\n * Checks if a continuation token indicates an exhausted partition.\n * @param continuationToken - The continuation token to check\n * @returns true if the partition is exhausted (null, empty, or \"null\" string)\n * @hidden\n */\nexport function isPartitionExhausted(continuationToken: string | undefined): boolean {\n  return (\n    !continuationToken ||\n    continuationToken === \"\" ||\n    continuationToken === \"null\" ||\n    continuationToken.toLowerCase() === \"null\"\n  );\n}\n\n/**\n * Manages partition key range mappings for query execution.\n * Handles range operations, offset/limit processing, and distinct query logic.\n * @hidden\n */\nexport class PartitionRangeManager {\n  private partitionKeyRangeMap: Map<string, QueryRangeMapping> = new Map();\n\n  constructor(initialPartitionKeyRangeMap?: Map<string, QueryRangeMapping>) {\n    if (initialPartitionKeyRangeMap) {\n      this.partitionKeyRangeMap = new Map(initialPartitionKeyRangeMap);\n    }\n  }\n\n  /**\n   * Gets a copy of the current partition key range map for constructor pattern\n   */\n  public getPartitionKeyRangeMap(): Map<string, QueryRangeMapping> {\n    return new Map(this.partitionKeyRangeMap);\n  }\n\n  /**\n   * Adds a range mapping to the partition key range map\n   * Does not allow updates to existing keys - only new additions\n   * @param rangeId - Unique identifier for the partition range\n   * @param mapping - The QueryRangeMapping to add\n   */\n  private addPartitionRangeMapping(rangeId: string, mapping: QueryRangeMapping): void {\n    if (!this.partitionKeyRangeMap.has(rangeId)) {\n      this.partitionKeyRangeMap.set(rangeId, mapping);\n    }\n  }\n\n  /**\n   * Removes a range mapping from the partition key range map\n   */\n  public removePartitionRangeMapping(rangeId: string): void {\n    this.partitionKeyRangeMap.delete(rangeId);\n  }\n\n  /**\n   * Updates the partition key range map with new mappings from the endpoint response\n   * @param partitionKeyRangeMap - Map of range IDs to QueryRangeMapping objects\n   */\n  public addPartitionKeyRangeMap(partitionKeyRangeMap: Map<string, QueryRangeMapping>): void {\n    if (partitionKeyRangeMap) {\n      for (const [rangeId, mapping] of partitionKeyRangeMap) {\n        this.addPartitionRangeMapping(rangeId, mapping);\n      }\n    }\n  }\n\n  /**\n   * Checks if there are any unprocessed ranges in the sliding window\n   */\n  public hasUnprocessedRanges(): boolean {\n    return this.partitionKeyRangeMap.size > 0;\n  }\n\n  /**\n   * Removes exhausted(fully drained) ranges from the given range mappings\n   * @param rangeMappings - Array of range mappings to filter\n   * @returns Filtered array without exhausted ranges\n   */\n  public removeExhaustedRanges(rangeMappings: QueryRangeMapping[]): QueryRangeMapping[] {\n    if (!rangeMappings || !Array.isArray(rangeMappings)) {\n      return [];\n    }\n\n    return rangeMappings.filter((mapping) => {\n      if (!mapping) {\n        return false;\n      }\n      const isExhausted = isPartitionExhausted(mapping.continuationToken);\n\n      if (isExhausted) {\n        return false;\n      }\n      return true;\n    });\n  }\n\n  /**\n   * Processes ranges for ORDER BY queries\n   */\n  public processOrderByRanges(pageSize: number): {\n    endIndex: number;\n    processedRanges: string[];\n    lastRangeBeforePageLimit: QueryRangeMapping | null;\n  } {\n    let endIndex = 0;\n    const processedRanges: string[] = [];\n    let lastRangeBeforePageLimit: QueryRangeMapping | null = null;\n    let rangeIndex = 0;\n    for (const [rangeId, value] of this.partitionKeyRangeMap) {\n      rangeIndex++;\n      const { itemCount } = value;\n      // Check if this complete range fits within remaining page size capacity\n      if (endIndex + itemCount <= pageSize) {\n        lastRangeBeforePageLimit = value;\n        endIndex += itemCount;\n        processedRanges.push(rangeId);\n      } else {\n        break;\n      }\n    }\n\n    return { endIndex, processedRanges, lastRangeBeforePageLimit };\n  }\n\n  public processEmptyOrderByRanges(ranges: QueryRangeWithContinuationToken[]): {\n    endIndex: number;\n    processedRanges: string[];\n    lastRangeBeforePageLimit: QueryRangeMapping | undefined;\n  } {\n    const endIndex = 0;\n    const processedRanges: string[] = [];\n    let lastRangeBeforePageLimit: QueryRangeMapping | undefined;\n\n    // since there is no data returned add all the ids to processed ranges\n    for (const [rangeId, _] of this.partitionKeyRangeMap) {\n      processedRanges.push(rangeId);\n    }\n    // search for matching range in the map(min max value exact match) and return that as lastRangeBeforePageLimit\n    for (const [_, mapping] of this.partitionKeyRangeMap) {\n      if (\n        mapping.partitionKeyRange!.minInclusive === ranges[0].queryRange.min &&\n        mapping.partitionKeyRange!.maxExclusive === ranges[0].queryRange.max\n      ) {\n        lastRangeBeforePageLimit = mapping;\n        break;\n      }\n    }\n\n    return { endIndex, processedRanges, lastRangeBeforePageLimit };\n  }\n  /**\n   * Processes ranges for parallel queries - multi-range aggregation\n   */\n  public processParallelRanges(pageSize: number): {\n    endIndex: number;\n    processedRanges: string[];\n    processedRangeMappings: QueryRangeMapping[];\n    lastPartitionBeforeCutoff?: { rangeId: string; mapping: QueryRangeMapping };\n  } {\n    let endIndex = 0;\n    const processedRanges: string[] = [];\n    const processedRangeMappings: QueryRangeMapping[] = [];\n    let rangesAggregatedInCurrentToken = 0;\n    let lastPartitionBeforeCutoff: { rangeId: string; mapping: QueryRangeMapping } | undefined;\n\n    for (const [rangeId, value] of this.partitionKeyRangeMap) {\n      rangesAggregatedInCurrentToken++;\n\n      // Validate range data\n      if (!value || value.itemCount === undefined) {\n        continue;\n      }\n\n      const { itemCount } = value;\n\n      // ASSUMPTION: Backend should respect maxItemCount and return pageSize or fewer items per partition.\n      // The logic below expects itemCount (items from a partition) to be <= pageSize.\n      // KNOWN ISSUE: Backend currently violates this contract for non-streaming queries (e.g., hybrid queries),\n      // returning more items per partition than maxItemCount specified. This causes pagination logic to fail,\n      // as ranges with itemCount > pageSize cannot fit and result in endIndex=0.\n      if (endIndex + itemCount <= pageSize) {\n        lastPartitionBeforeCutoff = { rangeId, mapping: value };\n        endIndex += itemCount;\n        processedRanges.push(rangeId);\n        processedRangeMappings.push(value);\n      } else {\n        break; // No more ranges can fit, exit loop\n      }\n    }\n\n    return { endIndex, processedRanges, processedRangeMappings, lastPartitionBeforeCutoff };\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/commonjs/queryExecutionContext/PartitionRangeUtils.js

@@ -1,109 +1,101 @@
-"use strict";
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateOffsetLimitForPartitionRanges = calculateOffsetLimitForPartitionRanges;
-exports.processDistinctQueryAndUpdateRangeMap = processDistinctQueryAndUpdateRangeMap;
-/**
- * Calculates offset/limit values after consuming each partition range sequentially
- * @param partitionKeyRangeMap - Map of range IDs to range mappings
- * @param initialOffset - Initial offset value
- * @param initialLimit - Initial limit value
- * @returns Updated partition key range map with calculated offset/limit values and updated itemCount
- * @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 PartitionRangeUtils_exports = {};
+__export(PartitionRangeUtils_exports, {
+  calculateOffsetLimitForPartitionRanges: () => calculateOffsetLimitForPartitionRanges,
+  processDistinctQueryAndUpdateRangeMap: () => processDistinctQueryAndUpdateRangeMap
+});
+module.exports = __toCommonJS(PartitionRangeUtils_exports);
 function calculateOffsetLimitForPartitionRanges(partitionKeyRangeMap, initialOffset, initialLimit) {
-    if (!partitionKeyRangeMap || partitionKeyRangeMap.size === 0) {
-        return partitionKeyRangeMap;
-    }
-    const updatedMap = new Map();
-    let currentOffset = initialOffset;
-    let currentLimit = initialLimit;
-    for (const [rangeId, rangeMapping] of partitionKeyRangeMap) {
-        const { itemCount } = rangeMapping;
-        let offsetAfterThisRange = currentOffset;
-        let limitAfterThisRange = currentLimit;
-        let updatedItemCount = itemCount;
-        if (itemCount > 0) {
-            if (currentOffset > 0) {
-                // Calculate how much offset this range consumes
-                const offsetConsumption = Math.min(currentOffset, itemCount);
-                offsetAfterThisRange = currentOffset - offsetConsumption;
-                // Calculate remaining items after offset consumption
-                const remainingItems = itemCount - offsetConsumption;
-                if (remainingItems > 0 && currentLimit > 0) {
-                    // Apply limit to remaining items
-                    const limitConsumption = Math.min(currentLimit, remainingItems);
-                    limitAfterThisRange = currentLimit - limitConsumption;
-                    // Update item count to reflect actual items that will be returned from this range
-                    updatedItemCount = limitConsumption;
-                }
-                else {
-                    // No items left after offset, or no limit remaining
-                    updatedItemCount = 0;
-                    limitAfterThisRange = currentLimit;
-                }
-            }
-            else if (currentLimit > 0) {
-                // No offset, but limit applies
-                const limitConsumption = Math.min(currentLimit, itemCount);
-                limitAfterThisRange = currentLimit - limitConsumption;
-                offsetAfterThisRange = 0;
-                // Update item count to reflect actual items that will be returned from this range
-                updatedItemCount = limitConsumption;
-            }
-            else {
-                // No limit remaining - this range contributes 0 items
-                updatedItemCount = 0;
-            }
-            // Update running totals for next iteration
-            currentOffset = offsetAfterThisRange;
-            currentLimit = limitAfterThisRange;
-        }
-        else {
-            // Range has no items to begin with
-            updatedItemCount = 0;
+  if (!partitionKeyRangeMap || partitionKeyRangeMap.size === 0) {
+    return partitionKeyRangeMap;
+  }
+  const updatedMap = /* @__PURE__ */ new Map();
+  let currentOffset = initialOffset;
+  let currentLimit = initialLimit;
+  for (const [rangeId, rangeMapping] of partitionKeyRangeMap) {
+    const { itemCount } = rangeMapping;
+    let offsetAfterThisRange = currentOffset;
+    let limitAfterThisRange = currentLimit;
+    let updatedItemCount = itemCount;
+    if (itemCount > 0) {
+      if (currentOffset > 0) {
+        const offsetConsumption = Math.min(currentOffset, itemCount);
+        offsetAfterThisRange = currentOffset - offsetConsumption;
+        const remainingItems = itemCount - offsetConsumption;
+        if (remainingItems > 0 && currentLimit > 0) {
+          const limitConsumption = Math.min(currentLimit, remainingItems);
+          limitAfterThisRange = currentLimit - limitConsumption;
+          updatedItemCount = limitConsumption;
+        } else {
+          updatedItemCount = 0;
+          limitAfterThisRange = currentLimit;
         }
-        updatedMap.set(rangeId, {
-            ...rangeMapping,
-            offset: offsetAfterThisRange,
-            limit: limitAfterThisRange,
-            itemCount: updatedItemCount,
-        });
+      } else if (currentLimit > 0) {
+        const limitConsumption = Math.min(currentLimit, itemCount);
+        limitAfterThisRange = currentLimit - limitConsumption;
+        offsetAfterThisRange = 0;
+        updatedItemCount = limitConsumption;
+      } else {
+        updatedItemCount = 0;
+      }
+      currentOffset = offsetAfterThisRange;
+      currentLimit = limitAfterThisRange;
+    } else {
+      updatedItemCount = 0;
     }
-    return updatedMap;
+    updatedMap.set(rangeId, {
+      ...rangeMapping,
+      offset: offsetAfterThisRange,
+      limit: limitAfterThisRange,
+      itemCount: updatedItemCount
+    });
+  }
+  return updatedMap;
 }
-/**
- * Processes distinct query logic and updates partition key range map with hashedLastResult
- * @param originalBuffer - Original buffer containing query results
- * @param partitionKeyRangeMap - Map of partition key ranges
- * @param hashFunction - Hash function for items
- * @returns Updated partition key range map with hashedLastResult for each range
- * @hidden
- */
 async function processDistinctQueryAndUpdateRangeMap(originalBuffer, partitionKeyRangeMap, hashFunction) {
-    if (!partitionKeyRangeMap || partitionKeyRangeMap.size === 0) {
-        return partitionKeyRangeMap;
-    }
-    const updatedMap = new Map();
-    let bufferIndex = 0;
-    for (const [rangeId, rangeMapping] of partitionKeyRangeMap) {
-        const { itemCount } = rangeMapping;
-        let lastHashForThisRange;
-        if (itemCount > 0 && bufferIndex <= originalBuffer.length) {
-            const rangeEndIndex = Math.min(bufferIndex + itemCount, originalBuffer.length);
-            const lastItemIndex = rangeEndIndex - 1;
-            const lastItem = originalBuffer[lastItemIndex];
-            if (lastItem) {
-                lastHashForThisRange = await hashFunction(lastItem);
-            }
-            bufferIndex = rangeEndIndex;
-        }
-        updatedMap.set(rangeId, {
-            ...rangeMapping,
-            hashedLastResult: lastHashForThisRange,
-        });
+  if (!partitionKeyRangeMap || partitionKeyRangeMap.size === 0) {
+    return partitionKeyRangeMap;
+  }
+  const updatedMap = /* @__PURE__ */ new Map();
+  let bufferIndex = 0;
+  for (const [rangeId, rangeMapping] of partitionKeyRangeMap) {
+    const { itemCount } = rangeMapping;
+    let lastHashForThisRange;
+    if (itemCount > 0 && bufferIndex <= originalBuffer.length) {
+      const rangeEndIndex = Math.min(bufferIndex + itemCount, originalBuffer.length);
+      const lastItemIndex = rangeEndIndex - 1;
+      const lastItem = originalBuffer[lastItemIndex];
+      if (lastItem) {
+        lastHashForThisRange = await hashFunction(lastItem);
+      }
+      bufferIndex = rangeEndIndex;
     }
-    return updatedMap;
+    updatedMap.set(rangeId, {
+      ...rangeMapping,
+      hashedLastResult: lastHashForThisRange
+    });
+  }
+  return updatedMap;
 }
-//# sourceMappingURL=PartitionRangeUtils.js.map
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  calculateOffsetLimitForPartitionRanges,
+  processDistinctQueryAndUpdateRangeMap
+});
+//# sourceMappingURL=PartitionRangeUtils.js.map

package/dist/commonjs/queryExecutionContext/PartitionRangeUtils.js.map

@@ -1 +1,7 @@
-{"version":3,"file":"PartitionRangeUtils.js","sourceRoot":"","sources":["../../../src/queryExecutionContext/PartitionRangeUtils.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\n/**\n * Calculates offset/limit values after consuming each partition range sequentially\n * @param partitionKeyRangeMap - Map of range IDs to range mappings\n * @param initialOffset - Initial offset value\n * @param initialLimit - Initial limit value\n * @returns Updated partition key range map with calculated offset/limit values and updated itemCount\n * @hidden\n */\nexport function calculateOffsetLimitForPartitionRanges(\n  partitionKeyRangeMap: Map<string, any>,\n  initialOffset: number,\n  initialLimit: number,\n): Map<string, any> {\n  if (!partitionKeyRangeMap || partitionKeyRangeMap.size === 0) {\n    return partitionKeyRangeMap;\n  }\n\n  const updatedMap = new Map<string, any>();\n  let currentOffset = initialOffset;\n  let currentLimit = initialLimit;\n\n  for (const [rangeId, rangeMapping] of partitionKeyRangeMap) {\n    const { itemCount } = rangeMapping;\n\n    let offsetAfterThisRange = currentOffset;\n    let limitAfterThisRange = currentLimit;\n    let updatedItemCount = itemCount;\n\n    if (itemCount > 0) {\n      if (currentOffset > 0) {\n        // Calculate how much offset this range consumes\n        const offsetConsumption = Math.min(currentOffset, itemCount);\n        offsetAfterThisRange = currentOffset - offsetConsumption;\n\n        // Calculate remaining items after offset consumption\n        const remainingItems = itemCount - offsetConsumption;\n\n        if (remainingItems > 0 && currentLimit > 0) {\n          // Apply limit to remaining items\n          const limitConsumption = Math.min(currentLimit, remainingItems);\n          limitAfterThisRange = currentLimit - limitConsumption;\n          // Update item count to reflect actual items that will be returned from this range\n          updatedItemCount = limitConsumption;\n        } else {\n          // No items left after offset, or no limit remaining\n          updatedItemCount = 0;\n          limitAfterThisRange = currentLimit;\n        }\n      } else if (currentLimit > 0) {\n        // No offset, but limit applies\n        const limitConsumption = Math.min(currentLimit, itemCount);\n        limitAfterThisRange = currentLimit - limitConsumption;\n        offsetAfterThisRange = 0;\n        // Update item count to reflect actual items that will be returned from this range\n        updatedItemCount = limitConsumption;\n      } else {\n        // No limit remaining - this range contributes 0 items\n        updatedItemCount = 0;\n      }\n\n      // Update running totals for next iteration\n      currentOffset = offsetAfterThisRange;\n      currentLimit = limitAfterThisRange;\n    } else {\n      // Range has no items to begin with\n      updatedItemCount = 0;\n    }\n\n    updatedMap.set(rangeId, {\n      ...rangeMapping,\n      offset: offsetAfterThisRange,\n      limit: limitAfterThisRange,\n      itemCount: updatedItemCount,\n    });\n  }\n\n  return updatedMap;\n}\n\n/**\n * Processes distinct query logic and updates partition key range map with hashedLastResult\n * @param originalBuffer - Original buffer containing query results\n * @param partitionKeyRangeMap - Map of partition key ranges\n * @param hashFunction - Hash function for items\n * @returns Updated partition key range map with hashedLastResult for each range\n * @hidden\n */\nexport async function processDistinctQueryAndUpdateRangeMap(\n  originalBuffer: any[],\n  partitionKeyRangeMap: Map<string, any>,\n  hashFunction: (item: any) => Promise<string>,\n): Promise<Map<string, any>> {\n  if (!partitionKeyRangeMap || partitionKeyRangeMap.size === 0) {\n    return partitionKeyRangeMap;\n  }\n\n  const updatedMap = new Map<string, any>();\n  let bufferIndex = 0;\n\n  for (const [rangeId, rangeMapping] of partitionKeyRangeMap) {\n    const { itemCount } = rangeMapping;\n\n    let lastHashForThisRange: string | undefined;\n    if (itemCount > 0 && bufferIndex <= originalBuffer.length) {\n      const rangeEndIndex = Math.min(bufferIndex + itemCount, originalBuffer.length);\n      const lastItemIndex = rangeEndIndex - 1;\n\n      const lastItem = originalBuffer[lastItemIndex];\n      if (lastItem) {\n        lastHashForThisRange = await hashFunction(lastItem);\n      }\n      bufferIndex = rangeEndIndex;\n    }\n\n    updatedMap.set(rangeId, {\n      ...rangeMapping,\n      hashedLastResult: lastHashForThisRange,\n    });\n  }\n\n  return updatedMap;\n}\n"]}
+{
+  "version": 3,
+  "sources": ["../../../src/queryExecutionContext/PartitionRangeUtils.ts"],
+  "sourcesContent": ["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\n/**\n * Calculates offset/limit values after consuming each partition range sequentially\n * @param partitionKeyRangeMap - Map of range IDs to range mappings\n * @param initialOffset - Initial offset value\n * @param initialLimit - Initial limit value\n * @returns Updated partition key range map with calculated offset/limit values and updated itemCount\n * @hidden\n */\nexport function calculateOffsetLimitForPartitionRanges(\n  partitionKeyRangeMap: Map<string, any>,\n  initialOffset: number,\n  initialLimit: number,\n): Map<string, any> {\n  if (!partitionKeyRangeMap || partitionKeyRangeMap.size === 0) {\n    return partitionKeyRangeMap;\n  }\n\n  const updatedMap = new Map<string, any>();\n  let currentOffset = initialOffset;\n  let currentLimit = initialLimit;\n\n  for (const [rangeId, rangeMapping] of partitionKeyRangeMap) {\n    const { itemCount } = rangeMapping;\n\n    let offsetAfterThisRange = currentOffset;\n    let limitAfterThisRange = currentLimit;\n    let updatedItemCount = itemCount;\n\n    if (itemCount > 0) {\n      if (currentOffset > 0) {\n        // Calculate how much offset this range consumes\n        const offsetConsumption = Math.min(currentOffset, itemCount);\n        offsetAfterThisRange = currentOffset - offsetConsumption;\n\n        // Calculate remaining items after offset consumption\n        const remainingItems = itemCount - offsetConsumption;\n\n        if (remainingItems > 0 && currentLimit > 0) {\n          // Apply limit to remaining items\n          const limitConsumption = Math.min(currentLimit, remainingItems);\n          limitAfterThisRange = currentLimit - limitConsumption;\n          // Update item count to reflect actual items that will be returned from this range\n          updatedItemCount = limitConsumption;\n        } else {\n          // No items left after offset, or no limit remaining\n          updatedItemCount = 0;\n          limitAfterThisRange = currentLimit;\n        }\n      } else if (currentLimit > 0) {\n        // No offset, but limit applies\n        const limitConsumption = Math.min(currentLimit, itemCount);\n        limitAfterThisRange = currentLimit - limitConsumption;\n        offsetAfterThisRange = 0;\n        // Update item count to reflect actual items that will be returned from this range\n        updatedItemCount = limitConsumption;\n      } else {\n        // No limit remaining - this range contributes 0 items\n        updatedItemCount = 0;\n      }\n\n      // Update running totals for next iteration\n      currentOffset = offsetAfterThisRange;\n      currentLimit = limitAfterThisRange;\n    } else {\n      // Range has no items to begin with\n      updatedItemCount = 0;\n    }\n\n    updatedMap.set(rangeId, {\n      ...rangeMapping,\n      offset: offsetAfterThisRange,\n      limit: limitAfterThisRange,\n      itemCount: updatedItemCount,\n    });\n  }\n\n  return updatedMap;\n}\n\n/**\n * Processes distinct query logic and updates partition key range map with hashedLastResult\n * @param originalBuffer - Original buffer containing query results\n * @param partitionKeyRangeMap - Map of partition key ranges\n * @param hashFunction - Hash function for items\n * @returns Updated partition key range map with hashedLastResult for each range\n * @hidden\n */\nexport async function processDistinctQueryAndUpdateRangeMap(\n  originalBuffer: any[],\n  partitionKeyRangeMap: Map<string, any>,\n  hashFunction: (item: any) => Promise<string>,\n): Promise<Map<string, any>> {\n  if (!partitionKeyRangeMap || partitionKeyRangeMap.size === 0) {\n    return partitionKeyRangeMap;\n  }\n\n  const updatedMap = new Map<string, any>();\n  let bufferIndex = 0;\n\n  for (const [rangeId, rangeMapping] of partitionKeyRangeMap) {\n    const { itemCount } = rangeMapping;\n\n    let lastHashForThisRange: string | undefined;\n    if (itemCount > 0 && bufferIndex <= originalBuffer.length) {\n      const rangeEndIndex = Math.min(bufferIndex + itemCount, originalBuffer.length);\n      const lastItemIndex = rangeEndIndex - 1;\n\n      const lastItem = originalBuffer[lastItemIndex];\n      if (lastItem) {\n        lastHashForThisRange = await hashFunction(lastItem);\n      }\n      bufferIndex = rangeEndIndex;\n    }\n\n    updatedMap.set(rangeId, {\n      ...rangeMapping,\n      hashedLastResult: lastHashForThisRange,\n    });\n  }\n\n  return updatedMap;\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAWO,SAAS,uCACd,sBACA,eACA,cACkB;AAClB,MAAI,CAAC,wBAAwB,qBAAqB,SAAS,GAAG;AAC5D,WAAO;AAAA,EACT;AAEA,QAAM,aAAa,oBAAI,IAAiB;AACxC,MAAI,gBAAgB;AACpB,MAAI,eAAe;AAEnB,aAAW,CAAC,SAAS,YAAY,KAAK,sBAAsB;AAC1D,UAAM,EAAE,UAAU,IAAI;AAEtB,QAAI,uBAAuB;AAC3B,QAAI,sBAAsB;AAC1B,QAAI,mBAAmB;AAEvB,QAAI,YAAY,GAAG;AACjB,UAAI,gBAAgB,GAAG;AAErB,cAAM,oBAAoB,KAAK,IAAI,eAAe,SAAS;AAC3D,+BAAuB,gBAAgB;AAGvC,cAAM,iBAAiB,YAAY;AAEnC,YAAI,iBAAiB,KAAK,eAAe,GAAG;AAE1C,gBAAM,mBAAmB,KAAK,IAAI,cAAc,cAAc;AAC9D,gCAAsB,eAAe;AAErC,6BAAmB;AAAA,QACrB,OAAO;AAEL,6BAAmB;AACnB,gCAAsB;AAAA,QACxB;AAAA,MACF,WAAW,eAAe,GAAG;AAE3B,cAAM,mBAAmB,KAAK,IAAI,cAAc,SAAS;AACzD,8BAAsB,eAAe;AACrC,+BAAuB;AAEvB,2BAAmB;AAAA,MACrB,OAAO;AAEL,2BAAmB;AAAA,MACrB;AAGA,sBAAgB;AAChB,qBAAe;AAAA,IACjB,OAAO;AAEL,yBAAmB;AAAA,IACrB;AAEA,eAAW,IAAI,SAAS;AAAA,MACtB,GAAG;AAAA,MACH,QAAQ;AAAA,MACR,OAAO;AAAA,MACP,WAAW;AAAA,IACb,CAAC;AAAA,EACH;AAEA,SAAO;AACT;AAUA,eAAsB,sCACpB,gBACA,sBACA,cAC2B;AAC3B,MAAI,CAAC,wBAAwB,qBAAqB,SAAS,GAAG;AAC5D,WAAO;AAAA,EACT;AAEA,QAAM,aAAa,oBAAI,IAAiB;AACxC,MAAI,cAAc;AAElB,aAAW,CAAC,SAAS,YAAY,KAAK,sBAAsB;AAC1D,UAAM,EAAE,UAAU,IAAI;AAEtB,QAAI;AACJ,QAAI,YAAY,KAAK,eAAe,eAAe,QAAQ;AACzD,YAAM,gBAAgB,KAAK,IAAI,cAAc,WAAW,eAAe,MAAM;AAC7E,YAAM,gBAAgB,gBAAgB;AAEtC,YAAM,WAAW,eAAe,aAAa;AAC7C,UAAI,UAAU;AACZ,+BAAuB,MAAM,aAAa,QAAQ;AAAA,MACpD;AACA,oBAAc;AAAA,IAChB;AAEA,eAAW,IAAI,SAAS;AAAA,MACtB,GAAG;AAAA,MACH,kBAAkB;AAAA,IACpB,CAAC;AAAA,EACH;AAEA,SAAO;AACT;",
+  "names": []
+}

package/dist/commonjs/queryExecutionContext/QueryControlFetchImplementation.js

@@ -1,97 +1,121 @@
-"use strict";
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.QueryControlFetchImplementation = void 0;
-const headerUtils_js_1 = require("./headerUtils.js");
-const ContinuationTokenManagerFactory_js_1 = require("./ContinuationTokenManager/ContinuationTokenManagerFactory.js");
-const index_js_1 = require("../common/index.js");
-/**
- * Query control enabled fetch implementation with continuation token support
- * @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 QueryControlFetchImplementation_exports = {};
+__export(QueryControlFetchImplementation_exports, {
+  QueryControlFetchImplementation: () => QueryControlFetchImplementation
+});
+module.exports = __toCommonJS(QueryControlFetchImplementation_exports);
+var import_headerUtils = require("./headerUtils.js");
+var import_ContinuationTokenManagerFactory = require("./ContinuationTokenManager/ContinuationTokenManagerFactory.js");
+var import_common = require("../common/index.js");
 class QueryControlFetchImplementation {
-    endpoint;
-    pageSize;
-    // Required fields for query control - not optional
-    continuationTokenManager;
-    querySupportsTokens;
-    constructor(endpoint, pageSize, collectionLink, continuationToken, isOrderByQuery, querySupportsTokens) {
-        this.endpoint = endpoint;
-        this.pageSize = pageSize;
-        this.querySupportsTokens = querySupportsTokens;
-        // Initialize continuation token manager immediately for query control
-        this.continuationTokenManager = ContinuationTokenManagerFactory_js_1.ContinuationTokenManagerFactory.create(collectionLink, continuationToken, isOrderByQuery);
+  constructor(endpoint, pageSize, collectionLink, continuationToken, isOrderByQuery, querySupportsTokens) {
+    this.endpoint = endpoint;
+    this.pageSize = pageSize;
+    this.querySupportsTokens = querySupportsTokens;
+    this.continuationTokenManager = import_ContinuationTokenManagerFactory.ContinuationTokenManagerFactory.create(
+      collectionLink,
+      continuationToken,
+      isOrderByQuery
+    );
+  }
+  endpoint;
+  pageSize;
+  // Required fields for query control - not optional
+  continuationTokenManager;
+  querySupportsTokens;
+  async fetchMore(diagnosticNode, fetchBuffer) {
+    const fetchMoreRespHeaders = (0, import_headerUtils.getInitialHeader)();
+    if (this.querySupportsTokens) {
+      return this._handleQueryFetch(diagnosticNode, fetchBuffer, fetchMoreRespHeaders);
+    } else {
+      return this._handleSimpleBufferFetch(diagnosticNode, fetchBuffer, fetchMoreRespHeaders);
     }
-    async fetchMore(diagnosticNode, fetchBuffer) {
-        // Initialize headers fresh for each fetchMore call
-        const fetchMoreRespHeaders = (0, headerUtils_js_1.getInitialHeader)();
-        // Use continuation token logic for supported queries when query control is enabled
-        // Otherwise use simplified buffer-only logic
-        if (this.querySupportsTokens) {
-            return this._handleQueryFetch(diagnosticNode, fetchBuffer, fetchMoreRespHeaders);
-        }
-        else {
-            return this._handleSimpleBufferFetch(diagnosticNode, fetchBuffer, fetchMoreRespHeaders);
-        }
+  }
+  async _handleSimpleBufferFetch(diagnosticNode, fetchBuffer, fetchMoreRespHeaders) {
+    if (fetchBuffer.length > 0) {
+      const temp2 = fetchBuffer.slice(0, this.pageSize);
+      fetchBuffer.splice(0, this.pageSize);
+      return { result: temp2, headers: fetchMoreRespHeaders };
     }
-    async _handleSimpleBufferFetch(diagnosticNode, fetchBuffer, fetchMoreRespHeaders) {
-        // Return buffered data if available
-        if (fetchBuffer.length > 0) {
-            const temp = fetchBuffer.slice(0, this.pageSize);
-            fetchBuffer.splice(0, this.pageSize); // Remove items in place
-            return { result: temp, headers: fetchMoreRespHeaders };
-        }
-        // Fetch new data from endpoint
-        const response = await this.endpoint.fetchMore(diagnosticNode);
-        (0, headerUtils_js_1.mergeHeaders)(fetchMoreRespHeaders, response.headers);
-        if (!response?.result?.buffer?.length) {
-            return this._createEmptyResult(response?.headers);
-        }
-        // Buffer new data and return up to pageSize
-        fetchBuffer.length = 0; // Clear existing items
-        fetchBuffer.push(...response.result.buffer); // Add new items
-        const temp = fetchBuffer.slice(0, this.pageSize);
-        fetchBuffer.splice(0, this.pageSize); // Remove returned items in place
-        return { result: temp, headers: fetchMoreRespHeaders };
+    const response = await this.endpoint.fetchMore(diagnosticNode);
+    (0, import_headerUtils.mergeHeaders)(fetchMoreRespHeaders, response.headers);
+    if (!response?.result?.buffer?.length) {
+      return this._createEmptyResult(response?.headers);
     }
-    async _handleQueryFetch(diagnosticNode, fetchBuffer, fetchMoreRespHeaders) {
-        if (fetchBuffer.length > 0) {
-            const { endIndex, continuationToken } = this.continuationTokenManager.paginateResults(this.pageSize, false);
-            const temp = fetchBuffer.slice(0, endIndex);
-            fetchBuffer.splice(0, endIndex); // Remove returned items in place
-            this._setContinuationTokenInHeaders(continuationToken, fetchMoreRespHeaders);
-            return { result: temp, headers: fetchMoreRespHeaders };
-        }
-        // Fetch new data from endpoint
-        fetchBuffer.length = 0; // Clear existing items in place
-        const response = await this.endpoint.fetchMore(diagnosticNode);
-        (0, headerUtils_js_1.mergeHeaders)(fetchMoreRespHeaders, response.headers);
-        if (!response?.result?.buffer || response.result.buffer.length === 0) {
-            const { continuationToken } = this.continuationTokenManager.paginateResults(this.pageSize, true, // isResponseEmpty = true
-            response?.result);
-            this._setContinuationTokenInHeaders(continuationToken, fetchMoreRespHeaders);
-            return this._createEmptyResult(fetchMoreRespHeaders);
-        }
-        fetchBuffer.push(...response.result.buffer); // Add new items to existing buffer
-        const { endIndex, continuationToken } = this.continuationTokenManager.paginateResults(this.pageSize, false, // isResponseEmpty = false
-        response.result);
-        const temp = fetchBuffer.slice(0, endIndex);
-        fetchBuffer.splice(0, endIndex); // Remove returned items in place
-        this._setContinuationTokenInHeaders(continuationToken, fetchMoreRespHeaders);
-        return { result: temp, headers: fetchMoreRespHeaders };
+    fetchBuffer.length = 0;
+    fetchBuffer.push(...response.result.buffer);
+    const temp = fetchBuffer.slice(0, this.pageSize);
+    fetchBuffer.splice(0, this.pageSize);
+    return { result: temp, headers: fetchMoreRespHeaders };
+  }
+  async _handleQueryFetch(diagnosticNode, fetchBuffer, fetchMoreRespHeaders) {
+    if (fetchBuffer.length > 0) {
+      const { endIndex: endIndex2, continuationToken: continuationToken2 } = this.continuationTokenManager.paginateResults(
+        this.pageSize,
+        false
+      );
+      const temp2 = fetchBuffer.slice(0, endIndex2);
+      fetchBuffer.splice(0, endIndex2);
+      this._setContinuationTokenInHeaders(continuationToken2, fetchMoreRespHeaders);
+      return { result: temp2, headers: fetchMoreRespHeaders };
     }
-    _setContinuationTokenInHeaders(continuationToken, fetchMoreRespHeaders) {
-        if (continuationToken) {
-            Object.assign(fetchMoreRespHeaders, {
-                [index_js_1.Constants.HttpHeaders.Continuation]: continuationToken,
-            });
-        }
+    fetchBuffer.length = 0;
+    const response = await this.endpoint.fetchMore(diagnosticNode);
+    (0, import_headerUtils.mergeHeaders)(fetchMoreRespHeaders, response.headers);
+    if (!response?.result?.buffer || response.result.buffer.length === 0) {
+      const { continuationToken: continuationToken2 } = this.continuationTokenManager.paginateResults(
+        this.pageSize,
+        true,
+        // isResponseEmpty = true
+        response?.result
+        // Pass response data for processing
+      );
+      this._setContinuationTokenInHeaders(continuationToken2, fetchMoreRespHeaders);
+      return this._createEmptyResult(fetchMoreRespHeaders);
     }
-    _createEmptyResult(headers) {
-        const hdrs = headers || (0, headerUtils_js_1.getInitialHeader)();
-        return { result: [], headers: hdrs };
+    fetchBuffer.push(...response.result.buffer);
+    const { endIndex, continuationToken } = this.continuationTokenManager.paginateResults(
+      this.pageSize,
+      false,
+      // isResponseEmpty = false
+      response.result
+      // Pass response data for processing
+    );
+    const temp = fetchBuffer.slice(0, endIndex);
+    fetchBuffer.splice(0, endIndex);
+    this._setContinuationTokenInHeaders(continuationToken, fetchMoreRespHeaders);
+    return { result: temp, headers: fetchMoreRespHeaders };
+  }
+  _setContinuationTokenInHeaders(continuationToken, fetchMoreRespHeaders) {
+    if (continuationToken) {
+      Object.assign(fetchMoreRespHeaders, {
+        [import_common.Constants.HttpHeaders.Continuation]: continuationToken
+      });
     }
+  }
+  _createEmptyResult(headers) {
+    const hdrs = headers || (0, import_headerUtils.getInitialHeader)();
+    return { result: [], headers: hdrs };
+  }
 }
-exports.QueryControlFetchImplementation = QueryControlFetchImplementation;
-//# sourceMappingURL=QueryControlFetchImplementation.js.map
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  QueryControlFetchImplementation
+});
+//# sourceMappingURL=QueryControlFetchImplementation.js.map

package/dist/commonjs/queryExecutionContext/QueryControlFetchImplementation.js.map

@@ -1 +1,7 @@
-{"version":3,"file":"QueryControlFetchImplementation.js","sourceRoot":"","sources":["../../../src/queryExecutionContext/QueryControlFetchImplementation.ts"],"names":[],"mappings":";AAAA,uCAAuC;AACvC,kCAAkC;;;AAIlC,qDAAkE;AAElE,sHAAgH;AAChH,iDAA+C;AAG/C;;;GAGG;AACH,MAAa,+BAA+B;IAMhC;IACA;IANV,mDAAmD;IAClC,wBAAwB,CAA+B;IACvD,mBAAmB,CAAU;IAE9C,YACU,QAA0B,EAC1B,QAAgB,EACxB,cAAsB,EACtB,iBAAqC,EACrC,cAAuB,EACvB,mBAA4B;QALpB,aAAQ,GAAR,QAAQ,CAAkB;QAC1B,aAAQ,GAAR,QAAQ,CAAQ;QAMxB,IAAI,CAAC,mBAAmB,GAAG,mBAAmB,CAAC;QAE/C,sEAAsE;QACtE,IAAI,CAAC,wBAAwB,GAAG,oEAA+B,CAAC,MAAM,CACpE,cAAc,EACd,iBAAiB,EACjB,cAAc,CACf,CAAC;IACJ,CAAC;IAED,KAAK,CAAC,SAAS,CACb,cAAsC,EACtC,WAAkB;QAElB,mDAAmD;QACnD,MAAM,oBAAoB,GAAG,IAAA,iCAAgB,GAAE,CAAC;QAEhD,mFAAmF;QACnF,6CAA6C;QAC7C,IAAI,IAAI,CAAC,mBAAmB,EAAE,CAAC;YAC7B,OAAO,IAAI,CAAC,iBAAiB,CAAC,cAAc,EAAE,WAAW,EAAE,oBAAoB,CAAC,CAAC;QACnF,CAAC;aAAM,CAAC;YACN,OAAO,IAAI,CAAC,wBAAwB,CAAC,cAAc,EAAE,WAAW,EAAE,oBAAoB,CAAC,CAAC;QAC1F,CAAC;IACH,CAAC;IAEO,KAAK,CAAC,wBAAwB,CACpC,cAAsC,EACtC,WAAkB,EAClB,oBAAyC;QAEzC,oCAAoC;QACpC,IAAI,WAAW,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC3B,MAAM,IAAI,GAAG,WAAW,CAAC,KAAK,CAAC,CAAC,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;YACjD,WAAW,CAAC,MAAM,CAAC,CAAC,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,wBAAwB;YAC9D,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,oBAAoB,EAAE,CAAC;QACzD,CAAC;QAED,+BAA+B;QAC/B,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,SAAU,CAAC,cAAc,CAAC,CAAC;QAChE,IAAA,6BAAY,EAAC,oBAAoB,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAC;QAErD,IAAI,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC;YACtC,OAAO,IAAI,CAAC,kBAAkB,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;QACpD,CAAC;QAED,4CAA4C;QAC5C,WAAW,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,uBAAuB;QAC/C,WAAW,CAAC,IAAI,CAAC,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,gBAAgB;QAC7D,MAAM,IAAI,GAAG,WAAW,CAAC,KAAK,CAAC,CAAC,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;QACjD,WAAW,CAAC,MAAM,CAAC,CAAC,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,iCAAiC;QAEvE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,oBAAoB,EAAE,CAAC;IACzD,CAAC;IAEO,KAAK,CAAC,iBAAiB,CAC7B,cAAsC,EACtC,WAAkB,EAClB,oBAAyC;QAEzC,IAAI,WAAW,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC3B,MAAM,EAAE,QAAQ,EAAE,iBAAiB,EAAE,GAAG,IAAI,CAAC,wBAAwB,CAAC,eAAe,CACnF,IAAI,CAAC,QAAQ,EACb,KAAK,CACN,CAAC;YACF,MAAM,IAAI,GAAG,WAAW,CAAC,KAAK,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC;YAC5C,WAAW,CAAC,MAAM,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,iCAAiC;YAClE,IAAI,CAAC,8BAA8B,CAAC,iBAAiB,EAAE,oBAAoB,CAAC,CAAC;YAE7E,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,oBAAoB,EAAE,CAAC;QACzD,CAAC;QAED,+BAA+B;QAC/B,WAAW,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,gCAAgC;QACxD,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,SAAU,CAAC,cAAc,CAAC,CAAC;QAChE,IAAA,6BAAY,EAAC,oBAAoB,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAC;QAErD,IAAI,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,IAAI,QAAQ,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACrE,MAAM,EAAE,iBAAiB,EAAE,GAAG,IAAI,CAAC,wBAAwB,CAAC,eAAe,CACzE,IAAI,CAAC,QAAQ,EACb,IAAI,EAAE,yBAAyB;YAC/B,QAAQ,EAAE,MAAM,CACjB,CAAC;YACF,IAAI,CAAC,8BAA8B,CAAC,iBAAiB,EAAE,oBAAoB,CAAC,CAAC;YAC7E,OAAO,IAAI,CAAC,kBAAkB,CAAC,oBAAoB,CAAC,CAAC;QACvD,CAAC;QAED,WAAW,CAAC,IAAI,CAAC,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,mCAAmC;QAChF,MAAM,EAAE,QAAQ,EAAE,iBAAiB,EAAE,GAAG,IAAI,CAAC,wBAAwB,CAAC,eAAe,CACnF,IAAI,CAAC,QAAQ,EACb,KAAK,EAAE,0BAA0B;QACjC,QAAQ,CAAC,MAAM,CAChB,CAAC;QAEF,MAAM,IAAI,GAAG,WAAW,CAAC,KAAK,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC;QAC5C,WAAW,CAAC,MAAM,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,iCAAiC;QAClE,IAAI,CAAC,8BAA8B,CAAC,iBAAiB,EAAE,oBAAoB,CAAC,CAAC;QAE7E,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,oBAAoB,EAAE,CAAC;IACzD,CAAC;IAEO,8BAA8B,CACpC,iBAAqC,EACrC,oBAAyC;QAEzC,IAAI,iBAAiB,EAAE,CAAC;YACtB,MAAM,CAAC,MAAM,CAAC,oBAAoB,EAAE;gBAClC,CAAC,oBAAS,CAAC,WAAW,CAAC,YAAY,CAAC,EAAE,iBAAiB;aACxD,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IAEO,kBAAkB,CAAC,OAAa;QACtC,MAAM,IAAI,GAAG,OAAO,IAAI,IAAA,iCAAgB,GAAE,CAAC;QAC3C,OAAO,EAAE,MAAM,EAAE,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;IACvC,CAAC;CACF;AAjID,0EAiIC","sourcesContent":["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nimport type { Response } from \"../request/index.js\";\nimport type { DiagnosticNodeInternal } from \"../diagnostics/DiagnosticNodeInternal.js\";\nimport { mergeHeaders, getInitialHeader } from \"./headerUtils.js\";\nimport type { BaseContinuationTokenManager } from \"./ContinuationTokenManager/BaseContinuationTokenManager.js\";\nimport { ContinuationTokenManagerFactory } from \"./ContinuationTokenManager/ContinuationTokenManagerFactory.js\";\nimport { Constants } from \"../common/index.js\";\nimport type { ExecutionContext } from \"./ExecutionContext.js\";\n\n/**\n * Query control enabled fetch implementation with continuation token support\n * @hidden\n */\nexport class QueryControlFetchImplementation {\n  // Required fields for query control - not optional\n  private readonly continuationTokenManager: BaseContinuationTokenManager;\n  private readonly querySupportsTokens: boolean;\n\n  constructor(\n    private endpoint: ExecutionContext,\n    private pageSize: number,\n    collectionLink: string,\n    continuationToken: string | undefined,\n    isOrderByQuery: boolean,\n    querySupportsTokens: boolean,\n  ) {\n    this.querySupportsTokens = querySupportsTokens;\n\n    // Initialize continuation token manager immediately for query control\n    this.continuationTokenManager = ContinuationTokenManagerFactory.create(\n      collectionLink,\n      continuationToken,\n      isOrderByQuery,\n    );\n  }\n\n  async fetchMore(\n    diagnosticNode: DiagnosticNodeInternal,\n    fetchBuffer: any[],\n  ): Promise<Response<any>> {\n    // Initialize headers fresh for each fetchMore call\n    const fetchMoreRespHeaders = getInitialHeader();\n\n    // Use continuation token logic for supported queries when query control is enabled\n    // Otherwise use simplified buffer-only logic\n    if (this.querySupportsTokens) {\n      return this._handleQueryFetch(diagnosticNode, fetchBuffer, fetchMoreRespHeaders);\n    } else {\n      return this._handleSimpleBufferFetch(diagnosticNode, fetchBuffer, fetchMoreRespHeaders);\n    }\n  }\n\n  private async _handleSimpleBufferFetch(\n    diagnosticNode: DiagnosticNodeInternal,\n    fetchBuffer: any[],\n    fetchMoreRespHeaders: Record<string, any>,\n  ): Promise<Response<any>> {\n    // Return buffered data if available\n    if (fetchBuffer.length > 0) {\n      const temp = fetchBuffer.slice(0, this.pageSize);\n      fetchBuffer.splice(0, this.pageSize); // Remove items in place\n      return { result: temp, headers: fetchMoreRespHeaders };\n    }\n\n    // Fetch new data from endpoint\n    const response = await this.endpoint.fetchMore!(diagnosticNode);\n    mergeHeaders(fetchMoreRespHeaders, response.headers);\n\n    if (!response?.result?.buffer?.length) {\n      return this._createEmptyResult(response?.headers);\n    }\n\n    // Buffer new data and return up to pageSize\n    fetchBuffer.length = 0; // Clear existing items\n    fetchBuffer.push(...response.result.buffer); // Add new items\n    const temp = fetchBuffer.slice(0, this.pageSize);\n    fetchBuffer.splice(0, this.pageSize); // Remove returned items in place\n\n    return { result: temp, headers: fetchMoreRespHeaders };\n  }\n\n  private async _handleQueryFetch(\n    diagnosticNode: DiagnosticNodeInternal,\n    fetchBuffer: any[],\n    fetchMoreRespHeaders: Record<string, any>,\n  ): Promise<Response<any>> {\n    if (fetchBuffer.length > 0) {\n      const { endIndex, continuationToken } = this.continuationTokenManager.paginateResults(\n        this.pageSize,\n        false,\n      );\n      const temp = fetchBuffer.slice(0, endIndex);\n      fetchBuffer.splice(0, endIndex); // Remove returned items in place\n      this._setContinuationTokenInHeaders(continuationToken, fetchMoreRespHeaders);\n\n      return { result: temp, headers: fetchMoreRespHeaders };\n    }\n\n    // Fetch new data from endpoint\n    fetchBuffer.length = 0; // Clear existing items in place\n    const response = await this.endpoint.fetchMore!(diagnosticNode);\n    mergeHeaders(fetchMoreRespHeaders, response.headers);\n\n    if (!response?.result?.buffer || response.result.buffer.length === 0) {\n      const { continuationToken } = this.continuationTokenManager.paginateResults(\n        this.pageSize,\n        true, // isResponseEmpty = true\n        response?.result, // Pass response data for processing\n      );\n      this._setContinuationTokenInHeaders(continuationToken, fetchMoreRespHeaders);\n      return this._createEmptyResult(fetchMoreRespHeaders);\n    }\n\n    fetchBuffer.push(...response.result.buffer); // Add new items to existing buffer\n    const { endIndex, continuationToken } = this.continuationTokenManager.paginateResults(\n      this.pageSize,\n      false, // isResponseEmpty = false\n      response.result, // Pass response data for processing\n    );\n\n    const temp = fetchBuffer.slice(0, endIndex);\n    fetchBuffer.splice(0, endIndex); // Remove returned items in place\n    this._setContinuationTokenInHeaders(continuationToken, fetchMoreRespHeaders);\n\n    return { result: temp, headers: fetchMoreRespHeaders };\n  }\n\n  private _setContinuationTokenInHeaders(\n    continuationToken: string | undefined,\n    fetchMoreRespHeaders: Record<string, any>,\n  ): void {\n    if (continuationToken) {\n      Object.assign(fetchMoreRespHeaders, {\n        [Constants.HttpHeaders.Continuation]: continuationToken,\n      });\n    }\n  }\n\n  private _createEmptyResult(headers?: any): Response<any> {\n    const hdrs = headers || getInitialHeader();\n    return { result: [], headers: hdrs };\n  }\n}\n"]}
+{
+  "version": 3,
+  "sources": ["../../../src/queryExecutionContext/QueryControlFetchImplementation.ts"],
+  "sourcesContent": ["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nimport type { Response } from \"../request/index.js\";\nimport type { DiagnosticNodeInternal } from \"../diagnostics/DiagnosticNodeInternal.js\";\nimport { mergeHeaders, getInitialHeader } from \"./headerUtils.js\";\nimport type { BaseContinuationTokenManager } from \"./ContinuationTokenManager/BaseContinuationTokenManager.js\";\nimport { ContinuationTokenManagerFactory } from \"./ContinuationTokenManager/ContinuationTokenManagerFactory.js\";\nimport { Constants } from \"../common/index.js\";\nimport type { ExecutionContext } from \"./ExecutionContext.js\";\n\n/**\n * Query control enabled fetch implementation with continuation token support\n * @hidden\n */\nexport class QueryControlFetchImplementation {\n  // Required fields for query control - not optional\n  private readonly continuationTokenManager: BaseContinuationTokenManager;\n  private readonly querySupportsTokens: boolean;\n\n  constructor(\n    private endpoint: ExecutionContext,\n    private pageSize: number,\n    collectionLink: string,\n    continuationToken: string | undefined,\n    isOrderByQuery: boolean,\n    querySupportsTokens: boolean,\n  ) {\n    this.querySupportsTokens = querySupportsTokens;\n\n    // Initialize continuation token manager immediately for query control\n    this.continuationTokenManager = ContinuationTokenManagerFactory.create(\n      collectionLink,\n      continuationToken,\n      isOrderByQuery,\n    );\n  }\n\n  async fetchMore(\n    diagnosticNode: DiagnosticNodeInternal,\n    fetchBuffer: any[],\n  ): Promise<Response<any>> {\n    // Initialize headers fresh for each fetchMore call\n    const fetchMoreRespHeaders = getInitialHeader();\n\n    // Use continuation token logic for supported queries when query control is enabled\n    // Otherwise use simplified buffer-only logic\n    if (this.querySupportsTokens) {\n      return this._handleQueryFetch(diagnosticNode, fetchBuffer, fetchMoreRespHeaders);\n    } else {\n      return this._handleSimpleBufferFetch(diagnosticNode, fetchBuffer, fetchMoreRespHeaders);\n    }\n  }\n\n  private async _handleSimpleBufferFetch(\n    diagnosticNode: DiagnosticNodeInternal,\n    fetchBuffer: any[],\n    fetchMoreRespHeaders: Record<string, any>,\n  ): Promise<Response<any>> {\n    // Return buffered data if available\n    if (fetchBuffer.length > 0) {\n      const temp = fetchBuffer.slice(0, this.pageSize);\n      fetchBuffer.splice(0, this.pageSize); // Remove items in place\n      return { result: temp, headers: fetchMoreRespHeaders };\n    }\n\n    // Fetch new data from endpoint\n    const response = await this.endpoint.fetchMore!(diagnosticNode);\n    mergeHeaders(fetchMoreRespHeaders, response.headers);\n\n    if (!response?.result?.buffer?.length) {\n      return this._createEmptyResult(response?.headers);\n    }\n\n    // Buffer new data and return up to pageSize\n    fetchBuffer.length = 0; // Clear existing items\n    fetchBuffer.push(...response.result.buffer); // Add new items\n    const temp = fetchBuffer.slice(0, this.pageSize);\n    fetchBuffer.splice(0, this.pageSize); // Remove returned items in place\n\n    return { result: temp, headers: fetchMoreRespHeaders };\n  }\n\n  private async _handleQueryFetch(\n    diagnosticNode: DiagnosticNodeInternal,\n    fetchBuffer: any[],\n    fetchMoreRespHeaders: Record<string, any>,\n  ): Promise<Response<any>> {\n    if (fetchBuffer.length > 0) {\n      const { endIndex, continuationToken } = this.continuationTokenManager.paginateResults(\n        this.pageSize,\n        false,\n      );\n      const temp = fetchBuffer.slice(0, endIndex);\n      fetchBuffer.splice(0, endIndex); // Remove returned items in place\n      this._setContinuationTokenInHeaders(continuationToken, fetchMoreRespHeaders);\n\n      return { result: temp, headers: fetchMoreRespHeaders };\n    }\n\n    // Fetch new data from endpoint\n    fetchBuffer.length = 0; // Clear existing items in place\n    const response = await this.endpoint.fetchMore!(diagnosticNode);\n    mergeHeaders(fetchMoreRespHeaders, response.headers);\n\n    if (!response?.result?.buffer || response.result.buffer.length === 0) {\n      const { continuationToken } = this.continuationTokenManager.paginateResults(\n        this.pageSize,\n        true, // isResponseEmpty = true\n        response?.result, // Pass response data for processing\n      );\n      this._setContinuationTokenInHeaders(continuationToken, fetchMoreRespHeaders);\n      return this._createEmptyResult(fetchMoreRespHeaders);\n    }\n\n    fetchBuffer.push(...response.result.buffer); // Add new items to existing buffer\n    const { endIndex, continuationToken } = this.continuationTokenManager.paginateResults(\n      this.pageSize,\n      false, // isResponseEmpty = false\n      response.result, // Pass response data for processing\n    );\n\n    const temp = fetchBuffer.slice(0, endIndex);\n    fetchBuffer.splice(0, endIndex); // Remove returned items in place\n    this._setContinuationTokenInHeaders(continuationToken, fetchMoreRespHeaders);\n\n    return { result: temp, headers: fetchMoreRespHeaders };\n  }\n\n  private _setContinuationTokenInHeaders(\n    continuationToken: string | undefined,\n    fetchMoreRespHeaders: Record<string, any>,\n  ): void {\n    if (continuationToken) {\n      Object.assign(fetchMoreRespHeaders, {\n        [Constants.HttpHeaders.Continuation]: continuationToken,\n      });\n    }\n  }\n\n  private _createEmptyResult(headers?: any): Response<any> {\n    const hdrs = headers || getInitialHeader();\n    return { result: [], headers: hdrs };\n  }\n}\n"],
+  "mappings": "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",
+  "names": ["temp", "endIndex", "continuationToken"]
+}