public async queryEntities()

in src/table/handlers/TableHandler.ts [623:723]
88 lines of code
9 McCabe index (conditional complexity)

  public async queryEntities(
    _table: string,
    options: Models.TableQueryEntitiesOptionalParams,
    context: Context
  ): Promise<Models.TableQueryEntitiesResponse> {
    const tableContext = new TableStorageContext(context);
    const table = this.getAndCheckTableName(tableContext);
    const account = this.getAndCheckAccountName(tableContext);
    const accept = this.getAndCheckPayloadFormat(tableContext);
    this.checkBodyLimit(context, context.request?.getBody());

    const [result, nextPartitionKey, nextRowKey] =
      await this.metadataStore.queryTableEntities(
        context,
        account,
        table,
        options.queryOptions || {},
        options.nextPartitionKey,
        options.nextRowKey
      );

    const response: Models.TableQueryEntitiesResponse = {
      clientRequestId: options.requestId,
      requestId: tableContext.contextID,
      version: TABLE_API_VERSION,
      date: context.startTime,
      xMsContinuationNextPartitionKey: nextPartitionKey,
      xMsContinuationNextRowKey: nextRowKey,
      statusCode: 200
    };

    let selectSet: Set<string> | undefined;
    const selectArray = options.queryOptions?.select
      ?.split(",")
      .filter((item) => {
        return typeof item === "string" && item.length > 0;
      })
      .map((item) => item.trim());
    if (selectArray && selectArray.length > 0) {
      selectSet = new Set(selectArray);
    }

    const entities: string[] = [];
    const odataPrefix = this.getOdataAnnotationUrlPrefix(tableContext, account);
    result.forEach((element) => {
      const entity = {} as any;
      const annotation = getEntityOdataAnnotationsForResponse(
        account,
        table,
        odataPrefix,
        element.PartitionKey,
        element.RowKey,
        accept
      );

      if (
        accept === MINIMAL_METADATA_ACCEPT ||
        accept === FULL_METADATA_ACCEPT
      ) {
        entity["odata.etag"] = element.eTag;
      }

      if (accept === FULL_METADATA_ACCEPT) {
        entity["odata.type"] = annotation.odatatype;
        entity["odata.id"] = annotation.odataid;
        entity["odata.editLink"] = annotation.odataeditLink;
      }

      const normalizedEntity = new NormalizedEntity(element);
      entities.push(
        normalizedEntity.toResponseString(accept, entity, selectSet)
      );
    });

    const odatametadata = getEntityOdataAnnotationsForResponse(
      account,
      table,
      odataPrefix,
      "",
      "",
      accept
    ).odatametadata;

    const odatametadataPariString = odatametadata
      ? `"odata.metadata":${JSON.stringify(odatametadata)},`
      : "";

    const body = `{${odatametadataPariString}"value":[${entities.join(",")}]}`;
    response.body = new BufferStream(Buffer.from(body));

    this.logger.debug(
      `TableHandler:queryEntities() Raw response string is ${JSON.stringify(
        body
      )}`,
      context.contextID
    );

    this.updateResponseAccept(tableContext, accept);

    return response;
  }