@azure/cosmos/dist/commonjs/queryExecutionContext/EndpointComponent/GroupByValueEndpointComponent.js

Microsoft Azure Cosmos DB Service Node.js SDK for NOSQL API

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 GroupByValueEndpointComponent_exports = {};
__export(GroupByValueEndpointComponent_exports, {
  GroupByValueEndpointComponent: () => GroupByValueEndpointComponent
});
module.exports = __toCommonJS(GroupByValueEndpointComponent_exports);
var import_hashObject = require("../../utils/hashObject.js");
var import_Aggregators = require("../Aggregators/index.js");
var import_headerUtils = require("../headerUtils.js");
var import_emptyGroup = require("./emptyGroup.js");
var import_parallelQueryResult = require("../parallelQueryResult.js");
class GroupByValueEndpointComponent {
  constructor(executionContext, queryInfo) {
    this.executionContext = executionContext;
    this.queryInfo = queryInfo;
    this.aggregateType = this.queryInfo.aggregates[0];
  }
  aggregators = /* @__PURE__ */ new Map();
  aggregateResultArray = [];
  aggregateType;
  completed = false;
  hasMoreResults() {
    return this.executionContext.hasMoreResults();
  }
  async fetchMore(diagnosticNode) {
    if (this.completed) {
      return {
        result: void 0,
        headers: (0, import_headerUtils.getInitialHeader)()
      };
    }
    const aggregateHeaders = (0, import_headerUtils.getInitialHeader)();
    const response = await this.executionContext.fetchMore(diagnosticNode);
    if (!response) {
      if (this.aggregators.size > 0) {
        return this.generateAggregateResponse(aggregateHeaders);
      }
      return { result: void 0, headers: aggregateHeaders };
    }
    (0, import_headerUtils.mergeHeaders)(aggregateHeaders, response.headers);
    if (response.result === void 0 || !Array.isArray(response.result.buffer) || response.result.buffer.length === 0) {
      if (this.aggregators.size > 0) {
        return this.generateAggregateResponse(aggregateHeaders);
      }
      return { result: void 0, headers: aggregateHeaders };
    }
    const parallelResult = response.result;
    const dataToProcess = parallelResult.buffer;
    for (const item of dataToProcess) {
      if (item) {
        let grouping = import_emptyGroup.emptyGroup;
        let payload = item;
        if (item.groupByItems) {
          payload = item.payload;
          grouping = await (0, import_hashObject.hashObject)(item.groupByItems);
        }
        const aggregator = this.aggregators.get(grouping);
        if (!aggregator) {
          this.aggregators.set(grouping, (0, import_Aggregators.createAggregator)(this.aggregateType));
        }
        if (this.aggregateType) {
          const aggregateResult = (0, import_emptyGroup.extractAggregateResult)(payload[0]);
          if (aggregateResult === null) {
            this.completed = true;
          }
          this.aggregators.get(grouping).aggregate(aggregateResult);
        } else {
          this.aggregators.get(grouping).aggregate(payload);
        }
      }
    }
    if (this.completed) {
      const result = (0, import_parallelQueryResult.createParallelQueryResult)([], /* @__PURE__ */ new Map());
      return {
        result,
        headers: aggregateHeaders
      };
    }
    if (this.executionContext.hasMoreResults()) {
      const result = (0, import_parallelQueryResult.createParallelQueryResult)(
        [],
        // empty buffer
        /* @__PURE__ */ new Map()
      );
      return { result, headers: aggregateHeaders };
    } else {
      return this.generateAggregateResponse(aggregateHeaders);
    }
  }
  generateAggregateResponse(aggregateHeaders) {
    for (const aggregator of this.aggregators.values()) {
      const result2 = aggregator.getResult();
      if (result2 !== void 0) {
        this.aggregateResultArray.push(result2);
      }
    }
    this.completed = true;
    const result = (0, import_parallelQueryResult.createParallelQueryResult)(this.aggregateResultArray, /* @__PURE__ */ new Map());
    return {
      result,
      headers: aggregateHeaders
    };
  }
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  GroupByValueEndpointComponent
});