async getAggregates()

in src/ServerClient/ADXTrenderClient.ts [123:215]
73 lines of code
6 McCabe index (conditional complexity)

  async getAggregates(
    tags: string[],
    startDate: Date,
    endDate: Date,
    interval: string
  ) {
    const aggregatesTableName = "TrenderAggregates";
    const metadataTableName = "TrenderMetadata";
    const result = await this.executeQuery(
      "declare query_parameters(TimeSeries:dynamic,StartTime:datetime,EndTime:datetime,Interval:timespan);" +
      `GetAggregates(TimeSeries, StartTime, EndTime, Interval) | order by TimeseriesId | as ${aggregatesTableName};
      GetMetaData(TimeSeries) | as ${metadataTableName}`,
      {
        parameters: {
          TimeSeries: `dynamic(${JSON.stringify(tags)})`,
          StartTime: startDate,
          EndTime: endDate,
          Interval: interval,
        },
      }
    );
    const table = result.getTable(aggregatesTableName);
    const metadataTable = result.getTable(metadataTableName)

    if (table.Rows.length == 0) {
      throw new Error("Aggregates array is empty.");
    }

    if (metadataTable.Rows.length == 0) {
      throw new Error("Aggregates array is empty.");
    }

    const metadata = result.unfoldTable<TagMetadata>(metadataTable).reduce((col, tag) => {
      col[tag.TimeseriesId] = tag;
      return col
    }, {} as Record<string, TagMetadata>)

    const headers = table.Columns.map((c) => c.ColumnName);
    headers.splice(0, 2);

    const grouped = table.Rows.reduce((prev, curr) => {
      const id = curr.shift() as string;
      const timestamp = curr.shift();

      const name = metadata[id].TimeseriesName

      const group = metadata[id].Path.slice(-1)

      if (!prev.hasOwnProperty(group)) {
        prev[group] = {};
      }

      if (!prev[group].hasOwnProperty(name)) {
        prev[group][name] = {};
      }

      prev[group][name][timestamp as string] = headers.reduce((obj, col, i) => {
        obj[col] = curr[i];
        return obj;
      }, {});

      return prev;
    }, {} as Record<string, Record<string, Record<string, unknown>>>);

    console.log(grouped)

    return Object.keys(grouped).map(key => {
      return {
        [key]: grouped[key]
      }
    })
      ;

    // Groups

    const groups = table.Rows.reduce((prev, curr) => {
      const id = curr.shift() as string;
      const timestamp = curr.shift();

      if (!prev.hasOwnProperty(id)) {
        prev[id] = { [id]: {} };
      }

      prev[id][id][timestamp] = headers.reduce((obj, col, i) => {
        obj[col] = curr[i];
        return obj;
      }, {});

      return prev;
    }, {});

    return Object.keys(groups).map((key) => ({ [key]: groups[key] }));
  }