@cumulus/db 18.3.4 → 19.0.0

package/dist/search/CollectionSearch.js

@@ -0,0 +1,162 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CollectionSearch = void 0;
+const pick_1 = __importDefault(require("lodash/pick"));
+const logger_1 = __importDefault(require("@cumulus/logger"));
+const BaseSearch_1 = require("./BaseSearch");
+const collections_1 = require("../translate/collections");
+const tables_1 = require("../tables");
+const log = new logger_1.default({ sender: '@cumulus/db/CollectionSearch' });
+/**
+ * Class to build and execute db search query for collections
+ */
+class CollectionSearch extends BaseSearch_1.BaseSearch {
+    constructor(event) {
+        const { active, includeStats, ...queryStringParameters } = event.queryStringParameters || {};
+        super({ queryStringParameters }, 'collection');
+        this.active = (active === 'true');
+        this.includeStats = (includeStats === 'true');
+    }
+    /**
+     * Build basic query
+     *
+     * @param knex - DB client
+     * @returns queries for getting count and search result
+     */
+    buildBasicQuery(knex) {
+        const countQuery = knex(this.tableName)
+            .count('*');
+        const searchQuery = knex(this.tableName)
+            .select(`${this.tableName}.*`);
+        return { countQuery, searchQuery };
+    }
+    /**
+     * Build queries for infix and prefix
+     *
+     * @param params
+     * @param params.countQuery - query builder for getting count
+     * @param params.searchQuery - query builder for search
+     * @param [params.dbQueryParameters] - db query parameters
+     */
+    buildInfixPrefixQuery(params) {
+        const { countQuery, searchQuery, dbQueryParameters } = params;
+        const { infix, prefix } = dbQueryParameters ?? this.dbQueryParameters;
+        if (infix) {
+            [countQuery, searchQuery].forEach((query) => query.whereLike(`${this.tableName}.name`, `%${infix}%`));
+        }
+        if (prefix) {
+            [countQuery, searchQuery].forEach((query) => query.whereLike(`${this.tableName}.name`, `%${prefix}%`));
+        }
+    }
+    /**
+     * Build queries for range fields
+     *
+     * @param params
+     * @param params.knex - db client
+     * @param [params.countQuery] - query builder for getting count
+     * @param params.searchQuery - query builder for search
+     * @param [params.dbQueryParameters] - db query parameters
+     */
+    buildRangeQuery(params) {
+        if (!this.active) {
+            super.buildRangeQuery(params);
+            return;
+        }
+        const granulesTable = tables_1.TableNames.granules;
+        const { knex, countQuery, searchQuery, dbQueryParameters } = params;
+        const { range = {} } = dbQueryParameters ?? this.dbQueryParameters;
+        const subQuery = knex.select(1).from(granulesTable)
+            .where(`${granulesTable}.collection_cumulus_id`, knex.raw(`${this.tableName}.cumulus_id`));
+        Object.entries(range).forEach(([name, rangeValues]) => {
+            if (rangeValues.gte) {
+                subQuery.where(`${granulesTable}.${name}`, '>=', rangeValues.gte);
+            }
+            if (rangeValues.lte) {
+                subQuery.where(`${granulesTable}.${name}`, '<=', rangeValues.lte);
+            }
+        });
+        subQuery.limit(1);
+        [countQuery, searchQuery].forEach((query) => query.whereExists(subQuery));
+    }
+    /**
+     * Executes stats query to get granules' status aggregation
+     *
+     * @param collectionCumulusIds - array of cumulusIds of the collections
+     * @param knex - knex for the stats query
+     * @returns the collection's granules status' aggregation
+     */
+    async retrieveGranuleStats(collectionCumulusIds, knex) {
+        const granulesTable = tables_1.TableNames.granules;
+        const statsQuery = knex(granulesTable)
+            .select(`${granulesTable}.collection_cumulus_id`, `${granulesTable}.status`)
+            .count('*')
+            .groupBy(`${granulesTable}.collection_cumulus_id`, `${granulesTable}.status`)
+            .whereIn(`${granulesTable}.collection_cumulus_id`, collectionCumulusIds);
+        if (this.active) {
+            Object.entries(this.dbQueryParameters?.range ?? {}).forEach(([name, rangeValues]) => {
+                if (rangeValues.gte) {
+                    statsQuery.where(`${granulesTable}.${name}`, '>=', rangeValues.gte);
+                }
+                if (rangeValues.lte) {
+                    statsQuery.where(`${granulesTable}.${name}`, '<=', rangeValues.lte);
+                }
+            });
+        }
+        log.debug(`retrieveGranuleStats statsQuery: ${statsQuery?.toSQL().sql}`);
+        const results = await statsQuery;
+        const reduced = results.reduce((acc, record) => {
+            const cumulusId = Number(record.collection_cumulus_id);
+            if (!acc[cumulusId]) {
+                acc[cumulusId] = {
+                    queued: 0,
+                    completed: 0,
+                    failed: 0,
+                    running: 0,
+                    total: 0,
+                };
+            }
+            acc[cumulusId][record.status] += Number(record.count);
+            acc[cumulusId]['total'] += Number(record.count);
+            return acc;
+        }, {});
+        return reduced;
+    }
+    /**
+     * Translate postgres records to api records
+     *
+     * @param pgRecords - postgres Collection records returned from query
+     * @param knex - knex for the stats query if incldueStats is true
+     * @returns translated api records
+     */
+    async translatePostgresRecordsToApiRecords(pgRecords, knex) {
+        log.debug(`translatePostgresRecordsToApiRecords number of records ${pgRecords.length} `);
+        let statsRecords;
+        const cumulusIds = pgRecords.map((record) => record.cumulus_id);
+        if (this.includeStats) {
+            statsRecords = await this.retrieveGranuleStats(cumulusIds, knex);
+        }
+        const apiRecords = pgRecords.map((record) => {
+            const apiRecord = (0, collections_1.translatePostgresCollectionToApiCollection)(record);
+            const apiRecordFinal = this.dbQueryParameters.fields
+                ? (0, pick_1.default)(apiRecord, this.dbQueryParameters.fields)
+                : apiRecord;
+            if (statsRecords) {
+                apiRecordFinal.stats = statsRecords[record.cumulus_id] ? statsRecords[record.cumulus_id]
+                    : {
+                        queued: 0,
+                        completed: 0,
+                        failed: 0,
+                        running: 0,
+                        total: 0,
+                    };
+            }
+            return apiRecordFinal;
+        });
+        return apiRecords;
+    }
+}
+exports.CollectionSearch = CollectionSearch;
+//# sourceMappingURL=CollectionSearch.js.map

package/dist/search/ExecutionSearch.d.ts

@@ -0,0 +1,62 @@
+import { Knex } from 'knex';
+import { ApiExecutionRecord } from '@cumulus/types/api/executions';
+import { BaseSearch } from './BaseSearch';
+import { DbQueryParameters, QueryEvent } from '../types/search';
+import { PostgresExecutionRecord } from '../types/execution';
+import { BaseRecord } from '../types/base';
+interface ExecutionRecord extends BaseRecord, PostgresExecutionRecord {
+    collectionName?: string;
+    collectionVersion?: string;
+    asyncOperationId?: string;
+    parentArn?: string;
+}
+/**
+ * Class to build and execute db search query for executions
+ */
+export declare class ExecutionSearch extends BaseSearch {
+    constructor(event: QueryEvent);
+    /**
+     * check if joined async_ops table search is needed
+     *
+     * @returns whether collection search is needed
+     */
+    protected searchAsync(): boolean;
+    /**
+     * check if joined async_ops table search is needed
+     *
+     * @returns whether collection search is needed
+     */
+    protected searchParent(): boolean;
+    /**
+     * Build basic query
+     *
+     * @param knex - DB client
+     * @returns queries for getting count and search result
+     */
+    protected buildBasicQuery(knex: Knex): {
+        countQuery: Knex.QueryBuilder;
+        searchQuery: Knex.QueryBuilder;
+    };
+    /**
+     * Build queries for infix and prefix
+     *
+     * @param params
+     * @param params.countQuery - query builder for getting count
+     * @param params.searchQuery - query builder for search
+     * @param [params.dbQueryParameters] - db query parameters
+     */
+    protected buildInfixPrefixQuery(params: {
+        countQuery: Knex.QueryBuilder;
+        searchQuery: Knex.QueryBuilder;
+        dbQueryParameters?: DbQueryParameters;
+    }): void;
+    /**
+     * Translate postgres records to api records
+     *
+     * @param pgRecords - postgres records returned from query
+     * @returns translated api records
+     */
+    protected translatePostgresRecordsToApiRecords(pgRecords: ExecutionRecord[]): Partial<ApiExecutionRecord>[];
+}
+export {};
+//# sourceMappingURL=ExecutionSearch.d.ts.map

package/dist/search/ExecutionSearch.js

@@ -0,0 +1,133 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExecutionSearch = void 0;
+const logger_1 = __importDefault(require("@cumulus/logger"));
+const pick_1 = __importDefault(require("lodash/pick"));
+const set_1 = __importDefault(require("lodash/set"));
+const Collections_1 = require("@cumulus/message/Collections");
+const BaseSearch_1 = require("./BaseSearch");
+const executions_1 = require("../translate/executions");
+const tables_1 = require("../tables");
+const log = new logger_1.default({ sender: '@cumulus/db/ExecutionSearch' });
+/**
+ * Class to build and execute db search query for executions
+ */
+class ExecutionSearch extends BaseSearch_1.BaseSearch {
+    constructor(event) {
+        // estimate the table rowcount by default
+        if (event?.queryStringParameters?.estimateTableRowCount !== 'false') {
+            (0, set_1.default)(event, 'queryStringParameters.estimateTableRowCount', 'true');
+        }
+        super(event, 'execution');
+    }
+    /**
+     * check if joined async_ops table search is needed
+     *
+     * @returns whether collection search is needed
+     */
+    searchAsync() {
+        const { not, term, terms } = this.dbQueryParameters;
+        return (!!(not?.asyncOperationId || term?.asyncOperationId || terms?.asyncOperationId));
+    }
+    /**
+     * check if joined async_ops table search is needed
+     *
+     * @returns whether collection search is needed
+     */
+    searchParent() {
+        const { not, term, terms } = this.dbQueryParameters;
+        return (!!(not?.parentArn || term?.parentArn || terms?.parentArn));
+    }
+    /**
+     * Build basic query
+     *
+     * @param knex - DB client
+     * @returns queries for getting count and search result
+     */
+    buildBasicQuery(knex) {
+        const { collections: collectionsTable, asyncOperations: asyncOperationsTable, executions: executionsTable, } = tables_1.TableNames;
+        const searchQuery = knex(`${this.tableName}`)
+            .select(`${this.tableName}.*`)
+            .select({
+            collectionName: `${collectionsTable}.name`,
+            collectionVersion: `${collectionsTable}.version`,
+        });
+        if (this.searchAsync() || this.dbQueryParameters.includeFullRecord) {
+            searchQuery.select({ asyncOperationId: `${asyncOperationsTable}.id` });
+        }
+        if (this.searchParent() || this.dbQueryParameters.includeFullRecord) {
+            searchQuery.select({ parentArn: `${executionsTable}_parent.arn` });
+        }
+        const countQuery = knex(this.tableName)
+            .count('*');
+        if (this.searchCollection()) {
+            countQuery.innerJoin(collectionsTable, `${this.tableName}.collection_cumulus_id`, `${collectionsTable}.cumulus_id`);
+            searchQuery.innerJoin(collectionsTable, `${this.tableName}.collection_cumulus_id`, `${collectionsTable}.cumulus_id`);
+        }
+        else {
+            searchQuery.leftJoin(collectionsTable, `${this.tableName}.collection_cumulus_id`, `${collectionsTable}.cumulus_id`);
+        }
+        if (this.searchAsync()) {
+            countQuery.innerJoin(asyncOperationsTable, `${this.tableName}.async_operation_cumulus_id`, `${asyncOperationsTable}.cumulus_id`);
+            searchQuery.innerJoin(asyncOperationsTable, `${this.tableName}.async_operation_cumulus_id`, `${asyncOperationsTable}.cumulus_id`);
+        }
+        else if (this.dbQueryParameters.includeFullRecord) {
+            searchQuery.leftJoin(asyncOperationsTable, `${this.tableName}.async_operation_cumulus_id`, `${asyncOperationsTable}.cumulus_id`);
+        }
+        if (this.searchParent()) {
+            countQuery.innerJoin(`${this.tableName} as ${this.tableName}_parent`, `${this.tableName}.parent_cumulus_id`, `${this.tableName}_parent.cumulus_id`);
+            searchQuery.innerJoin(`${this.tableName} as ${this.tableName}_parent`, `${this.tableName}.parent_cumulus_id`, `${this.tableName}_parent.cumulus_id`);
+        }
+        else if (this.dbQueryParameters.includeFullRecord) {
+            searchQuery.leftJoin(`${this.tableName} as ${this.tableName}_parent`, `${this.tableName}.parent_cumulus_id`, `${this.tableName}_parent.cumulus_id`);
+        }
+        return { countQuery, searchQuery };
+    }
+    /**
+     * Build queries for infix and prefix
+     *
+     * @param params
+     * @param params.countQuery - query builder for getting count
+     * @param params.searchQuery - query builder for search
+     * @param [params.dbQueryParameters] - db query parameters
+     */
+    buildInfixPrefixQuery(params) {
+        const { countQuery, searchQuery, dbQueryParameters } = params;
+        const { infix, prefix } = dbQueryParameters ?? this.dbQueryParameters;
+        if (infix) {
+            [countQuery, searchQuery].forEach((query) => query.whereLike(`${this.tableName}.arn`, `%${infix}%`));
+        }
+        if (prefix) {
+            [countQuery, searchQuery].forEach((query) => query.whereLike(`${this.tableName}.arn`, `%${prefix}%`));
+        }
+    }
+    /**
+     * Translate postgres records to api records
+     *
+     * @param pgRecords - postgres records returned from query
+     * @returns translated api records
+     */
+    translatePostgresRecordsToApiRecords(pgRecords) {
+        log.debug(`translatePostgresRecordsToApiRecords number of records ${pgRecords.length} `);
+        const apiRecords = pgRecords.map((executionRecord) => {
+            const { collectionName, collectionVersion, asyncOperationId, parentArn } = executionRecord;
+            const collectionId = collectionName && collectionVersion
+                ? (0, Collections_1.constructCollectionId)(collectionName, collectionVersion) : undefined;
+            const apiRecord = (0, executions_1.translatePostgresExecutionToApiExecutionWithoutDbQuery)({
+                executionRecord,
+                collectionId,
+                asyncOperationId,
+                parentArn,
+            });
+            return this.dbQueryParameters.fields
+                ? (0, pick_1.default)(apiRecord, this.dbQueryParameters.fields)
+                : apiRecord;
+        });
+        return apiRecords;
+    }
+}
+exports.ExecutionSearch = ExecutionSearch;
+//# sourceMappingURL=ExecutionSearch.js.map

package/dist/search/GranuleSearch.d.ts

@@ -0,0 +1,55 @@
+import { Knex } from 'knex';
+import { ApiGranuleRecord } from '@cumulus/types/api/granules';
+import { BaseRecord } from '../types/base';
+import { BaseSearch } from './BaseSearch';
+import { DbQueryParameters, QueryEvent } from '../types/search';
+import { PostgresGranuleRecord } from '../types/granule';
+interface GranuleRecord extends BaseRecord, PostgresGranuleRecord {
+    cumulus_id: number;
+    updated_at: Date;
+    collection_cumulus_id: number;
+    collectionName: string;
+    collectionVersion: string;
+    pdr_cumulus_id: number;
+    pdrName?: string;
+    provider_cumulus_id?: number;
+    providerName?: string;
+}
+/**
+ * Class to build and execute db search query for granules
+ */
+export declare class GranuleSearch extends BaseSearch {
+    constructor(event: QueryEvent);
+    /**
+     * Build basic query
+     *
+     * @param knex - DB client
+     * @returns queries for getting count and search result
+     */
+    protected buildBasicQuery(knex: Knex): {
+        countQuery: Knex.QueryBuilder;
+        searchQuery: Knex.QueryBuilder;
+    };
+    /**
+     * Build queries for infix and prefix
+     *
+     * @param params
+     * @param params.countQuery - query builder for getting count
+     * @param params.searchQuery - query builder for search
+     * @param [params.dbQueryParameters] - db query parameters
+     */
+    protected buildInfixPrefixQuery(params: {
+        countQuery: Knex.QueryBuilder;
+        searchQuery: Knex.QueryBuilder;
+        dbQueryParameters?: DbQueryParameters;
+    }): void;
+    /**
+     * Translate postgres records to api records
+     *
+     * @param pgRecords - postgres records returned from query
+     * @returns translated api records
+     */
+    protected translatePostgresRecordsToApiRecords(pgRecords: GranuleRecord[]): Partial<ApiGranuleRecord>[];
+}
+export {};
+//# sourceMappingURL=GranuleSearch.d.ts.map

package/dist/search/GranuleSearch.js

@@ -0,0 +1,109 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GranuleSearch = void 0;
+const pick_1 = __importDefault(require("lodash/pick"));
+const set_1 = __importDefault(require("lodash/set"));
+const logger_1 = __importDefault(require("@cumulus/logger"));
+const BaseSearch_1 = require("./BaseSearch");
+const granules_1 = require("../translate/granules");
+const tables_1 = require("../tables");
+const log = new logger_1.default({ sender: '@cumulus/db/GranuleSearch' });
+/**
+ * Class to build and execute db search query for granules
+ */
+class GranuleSearch extends BaseSearch_1.BaseSearch {
+    constructor(event) {
+        // estimate the table rowcount by default
+        if (event?.queryStringParameters?.estimateTableRowCount !== 'false') {
+            (0, set_1.default)(event, 'queryStringParameters.estimateTableRowCount', 'true');
+        }
+        super(event, 'granule');
+    }
+    /**
+     * Build basic query
+     *
+     * @param knex - DB client
+     * @returns queries for getting count and search result
+     */
+    buildBasicQuery(knex) {
+        const { collections: collectionsTable, providers: providersTable, pdrs: pdrsTable, } = tables_1.TableNames;
+        const countQuery = knex(this.tableName)
+            .count('*');
+        const searchQuery = knex(this.tableName)
+            .select(`${this.tableName}.*`)
+            .select({
+            providerName: `${providersTable}.name`,
+            collectionName: `${collectionsTable}.name`,
+            collectionVersion: `${collectionsTable}.version`,
+            pdrName: `${pdrsTable}.name`,
+        })
+            .innerJoin(collectionsTable, `${this.tableName}.collection_cumulus_id`, `${collectionsTable}.cumulus_id`);
+        if (this.searchCollection()) {
+            countQuery.innerJoin(collectionsTable, `${this.tableName}.collection_cumulus_id`, `${collectionsTable}.cumulus_id`);
+        }
+        if (this.searchProvider()) {
+            countQuery.innerJoin(providersTable, `${this.tableName}.provider_cumulus_id`, `${providersTable}.cumulus_id`);
+            searchQuery.innerJoin(providersTable, `${this.tableName}.provider_cumulus_id`, `${providersTable}.cumulus_id`);
+        }
+        else {
+            searchQuery.leftJoin(providersTable, `${this.tableName}.provider_cumulus_id`, `${providersTable}.cumulus_id`);
+        }
+        if (this.searchPdr()) {
+            countQuery.innerJoin(pdrsTable, `${this.tableName}.pdr_cumulus_id`, `${pdrsTable}.cumulus_id`);
+            searchQuery.innerJoin(pdrsTable, `${this.tableName}.pdr_cumulus_id`, `${pdrsTable}.cumulus_id`);
+        }
+        else {
+            searchQuery.leftJoin(pdrsTable, `${this.tableName}.pdr_cumulus_id`, `${pdrsTable}.cumulus_id`);
+        }
+        return { countQuery, searchQuery };
+    }
+    /**
+     * Build queries for infix and prefix
+     *
+     * @param params
+     * @param params.countQuery - query builder for getting count
+     * @param params.searchQuery - query builder for search
+     * @param [params.dbQueryParameters] - db query parameters
+     */
+    buildInfixPrefixQuery(params) {
+        const { countQuery, searchQuery, dbQueryParameters } = params;
+        const { infix, prefix } = dbQueryParameters ?? this.dbQueryParameters;
+        if (infix) {
+            [countQuery, searchQuery].forEach((query) => query.whereLike(`${this.tableName}.granule_id`, `%${infix}%`));
+        }
+        if (prefix) {
+            [countQuery, searchQuery].forEach((query) => query.whereLike(`${this.tableName}.granule_id`, `${prefix}%`));
+        }
+    }
+    /**
+     * Translate postgres records to api records
+     *
+     * @param pgRecords - postgres records returned from query
+     * @returns translated api records
+     */
+    translatePostgresRecordsToApiRecords(pgRecords) {
+        log.debug(`translatePostgresRecordsToApiRecords number of records ${pgRecords.length} `);
+        const apiRecords = pgRecords.map((item) => {
+            const granulePgRecord = item;
+            const collectionPgRecord = {
+                cumulus_id: item.collection_cumulus_id,
+                name: item.collectionName,
+                version: item.collectionVersion,
+            };
+            const pdr = item.pdrName ? { name: item.pdrName } : undefined;
+            const providerPgRecord = item.providerName ? { name: item.providerName } : undefined;
+            const apiRecord = (0, granules_1.translatePostgresGranuleToApiGranuleWithoutDbQuery)({
+                granulePgRecord, collectionPgRecord, pdr, providerPgRecord,
+            });
+            return this.dbQueryParameters.fields
+                ? (0, pick_1.default)(apiRecord, this.dbQueryParameters.fields)
+                : apiRecord;
+        });
+        return apiRecords;
+    }
+}
+exports.GranuleSearch = GranuleSearch;
+//# sourceMappingURL=GranuleSearch.js.map

package/dist/search/StatsSearch.d.ts

@@ -0,0 +1,111 @@
+import { Knex } from 'knex';
+import { DbQueryParameters, QueryEvent } from '../types/search';
+import { BaseSearch } from './BaseSearch';
+declare type Summary = {
+    dateFrom: string;
+    dateTo: string;
+    value: number;
+    aggregation: string;
+    unit: string;
+};
+declare type SummaryResult = {
+    errors: Summary;
+    granules: Summary;
+    collections: Summary;
+    processingTime: Summary;
+};
+declare type Meta = {
+    name: string;
+    count: number;
+    field: string;
+};
+declare type AggregateRes = {
+    key: string;
+    count: number;
+};
+declare type ApiAggregateResult = {
+    meta: Meta;
+    count: AggregateRes[];
+};
+/**
+ * A class to query postgres for the STATS and STATS/AGGREGATE endpoints
+ */
+declare class StatsSearch extends BaseSearch {
+    readonly field: string;
+    constructor(event: QueryEvent, type: string);
+    /**
+     * Formats the postgres records into an API stats/aggregate response
+     *
+     * @param result - the postgres query results
+     * @returns the api object with the aggregate statistics
+     */
+    private formatAggregateResult;
+    /**
+     * Formats the postgres results into an API stats/summary response
+     *
+     * @param result - the knex summary query results
+     * @returns the api object with the summary statistics
+     */
+    private formatSummaryResult;
+    /**
+     * Queries postgres for a summary of statistics around the granules in the system
+     *
+     * @param testKnex - the knex client to be used
+     * @returns the postgres aggregations based on query
+     */
+    summary(testKnex?: Knex): Promise<SummaryResult>;
+    /**
+     * Performs joins on the collections/pdrs/providers table if neccessary
+     *
+     * @param query - the knex query to be joined or not
+     */
+    private joinTables;
+    /**
+     * Aggregates the search query based on queryStringParameters
+     *
+     * @param query - the knex query to be aggregated
+     * @param knex - the knex client to be used
+     */
+    private aggregateQueryField;
+    /**
+     * Builds basic query
+     *
+     * @param knex - the knex client
+     * @returns the search query
+     */
+    protected buildBasicQuery(knex: Knex): {
+        searchQuery: Knex.QueryBuilder;
+    };
+    /**
+     * Builds queries for infix and prefix
+     *
+     * @param params
+     * @param params.searchQuery - the search query
+     * @param [params.dbQueryParameters] - the db query parameters
+     */
+    protected buildInfixPrefixQuery(params: {
+        searchQuery: Knex.QueryBuilder;
+        dbQueryParameters?: DbQueryParameters;
+    }): void;
+    /**
+     * Builds queries for term fields
+     *
+     * @param params
+     * @param params.searchQuery - the search query
+     * @param [params.dbQueryParameters] - the db query parameters
+     * @returns the updated search query based on queryStringParams
+     */
+    protected buildTermQuery(params: {
+        searchQuery: Knex.QueryBuilder;
+        dbQueryParameters?: DbQueryParameters;
+    }): void;
+    /**
+     * Executes the aggregate search query
+     *
+     * @param testKnex - the knex client to be used
+     * @returns the aggregate query results in api format
+     */
+    aggregate(testKnex?: Knex): Promise<ApiAggregateResult>;
+}
+export { StatsSearch };
+//# sourceMappingURL=StatsSearch.d.ts.map