AdvancedSearchManager.ts

// set up environment
import * as dotenv from 'dotenv';
dotenv.config();

import { CveResult } from '../result/CveResult.js';
import { SearchResultData } from "./SearchResultData.js";
import { SearchProviderSpec } from '../adapters/search/SearchAdapter.js';
import { BasicSearchManager, SearchOptions } from "./BasicSearchManager.js"

export class SearchAPIOptions extends SearchOptions {
  searchFields: Array<string>;
  filters: Array<object>;
  resultsPerPage: number;
  pageNumber: number;
  rangeObjects: Array<rangeObject>
  rangeStart: Date;
  rangeEnd: Date;
  rangeField: string;
}

//support for date ranges
export class rangeObject {
  rangeField: string;
  rangeStart: Date;
  rangeEnd: Date;
}

export class AdvancedSearchManager extends BasicSearchManager {

  /** constructor that sets up provider information
   *  @param searchProviderSpec optional specifications providing provider information
   *                            default is to read it from environment variables
   */
  constructor(searchProviderSpec: SearchProviderSpec = undefined) {
    super(searchProviderSpec);
  }

  /** search for text at search provider
   *  @param searchText the text string to search for
   *  @param options options to specify how to search, with well-defined defaults
   *  @param queryString query strings for each filter on the search request
   */
  async apiSearch(searchText: string, options: Partial<SearchAPIOptions> = undefined, queryStrings?: Array<object>): Promise<CveResult> {
     let response = undefined;

    if (!options) {
      options = {
        useCache: true,
        searchFields: null,
        filters: null,
        resultsPerPage: 20,
        pageNumber: 0,
        rangeObjects: null,
        rangeStart: null,
        rangeEnd: null,
        rangeField: null,
        track_total_hits: true,
        default_operator: "AND",
        metadataOnly: false,
        fields: []
      };
    }

    const validateResult = this.validateSearchText(searchText, options.filters)

    //Build range object to add to the query
    const rangeArray = [...(options.rangeObjects ?? [])];

    //Build query object
    const queryObj = {
      must: [],
      filter: [
        ...options.filters
      ],
    };

    //Add rangeObj only if it exists
    if (rangeArray) {
      queryObj.filter.push(...rangeArray);
    }

    if (searchText != null) {
      queryObj.must = [
        {
          query_string: {
            query: searchText,
            fields: ["containers.cna.descriptions.value"]
          },
        }
      ];
    }

    //Add query_string only if there is text to search
    else if (queryStrings != null) {
      queryObj.must = [
        ...queryStrings
      ];
    } else {
      delete queryObj.must
    }
   
    if (validateResult.isOk()) {

      response = await this._searchReader._client.search({
        index: this._searchReader._cveIndex,
        body: {
          query: {
            bool: queryObj

          },
          track_total_hits: true,
          size: options.resultsPerPage,
          from: options.from
        }
      });

      return CveResult.ok(response.body as SearchResultData);
    }
    else {
      return validateResult
    }
  }

  /** validates search text string and marks up CveResult
   *  with errors and/or notes, if any
   */
  // @todo
  validateSearchText(text: string, filters: Array<object>): CveResult {

    let result: CveResult
    if (!text && !filters) {
      result = CveResult.error(9002)
    }
    else {
      result = CveResult.ok("", ["no validation was done"])
    }

    return result
  }
}