@cumulus/db 18.4.0 → 19.0.0

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

package/dist/search/StatsSearch.js

@@ -0,0 +1,214 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StatsSearch = void 0;
+const omit_1 = __importDefault(require("lodash/omit"));
+const logger_1 = __importDefault(require("@cumulus/logger"));
+const connection_1 = require("../connection");
+const tables_1 = require("../tables");
+const BaseSearch_1 = require("./BaseSearch");
+const log = new logger_1.default({ sender: '@cumulus/db/StatsSearch' });
+const infixMapping = {
+    granules: 'granule_id',
+    collections: 'name',
+    providers: 'name',
+    executions: 'arn',
+    pdrs: 'name',
+};
+/**
+ * A class to query postgres for the STATS and STATS/AGGREGATE endpoints
+ */
+class StatsSearch extends BaseSearch_1.BaseSearch {
+    constructor(event, type) {
+        const { field, ...queryStringParameters } = event.queryStringParameters || {};
+        super({ queryStringParameters }, type);
+        this.field = field ?? 'status';
+        this.dbQueryParameters = (0, omit_1.default)(this.dbQueryParameters, ['limit', 'offset']);
+    }
+    /**
+     * Formats the postgres records into an API stats/aggregate response
+     *
+     * @param result - the postgres query results
+     * @returns the api object with the aggregate statistics
+     */
+    formatAggregateResult(result) {
+        let totalCount = 0;
+        const responses = [];
+        for (const row of Object.keys(result)) {
+            responses.push({
+                key: result[row].aggregatedfield,
+                count: Number.parseInt(result[row].count, 10),
+            });
+            totalCount += Number(result[row].count);
+        }
+        return {
+            meta: {
+                name: 'cumulus-api',
+                count: totalCount,
+                field: this.field,
+            },
+            count: responses,
+        };
+    }
+    /**
+     * 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
+     */
+    formatSummaryResult(result) {
+        const timestampTo = this.dbQueryParameters.range?.updated_at?.lte ?? new Date();
+        const timestampFrom = this.dbQueryParameters.range?.updated_at?.gte ?? new Date(0);
+        const dateto = timestampTo.toISOString();
+        const datefrom = timestampFrom.toISOString();
+        return {
+            errors: {
+                dateFrom: datefrom,
+                dateTo: dateto,
+                value: Number(result.count_errors),
+                aggregation: 'count',
+                unit: 'error',
+            },
+            collections: {
+                dateFrom: datefrom,
+                dateTo: dateto,
+                value: Number(result.count_collections),
+                aggregation: 'count',
+                unit: 'collection',
+            },
+            processingTime: {
+                dateFrom: datefrom,
+                dateTo: dateto,
+                value: Number(result.avg_processing_time),
+                aggregation: 'average',
+                unit: 'second',
+            },
+            granules: {
+                dateFrom: datefrom,
+                dateTo: dateto,
+                value: Number(result.count_granules),
+                aggregation: 'count',
+                unit: 'granule',
+            },
+        };
+    }
+    /**
+     * 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
+     */
+    async summary(testKnex) {
+        const knex = testKnex ?? await (0, connection_1.getKnexClient)();
+        const aggregateQuery = knex(this.tableName);
+        this.buildRangeQuery({ searchQuery: aggregateQuery });
+        aggregateQuery.select(knex.raw(`COUNT(CASE WHEN ${this.tableName}.error ->> 'Error' is not null THEN 1 END) AS count_errors`), knex.raw('COUNT(*) AS count_granules'), knex.raw(`AVG(${this.tableName}.duration) AS avg_processing_time`), knex.raw(`COUNT(DISTINCT ${this.tableName}.collection_cumulus_id) AS count_collections`));
+        log.debug(`summary about to execute query: ${aggregateQuery?.toSQL().sql}`);
+        const aggregateQueryRes = await aggregateQuery;
+        return this.formatSummaryResult(aggregateQueryRes[0]);
+    }
+    /**
+     * Performs joins on the collections/pdrs/providers table if neccessary
+     *
+     * @param query - the knex query to be joined or not
+     */
+    joinTables(query) {
+        const { collections: collectionsTable, providers: providersTable, pdrs: pdrsTable, } = tables_1.TableNames;
+        if (this.searchCollection()) {
+            query.join(collectionsTable, `${this.tableName}.collection_cumulus_id`, `${collectionsTable}.cumulus_id`);
+        }
+        if (this.searchProvider()) {
+            query.join(providersTable, `${this.tableName}.provider_cumulus_id`, `${providersTable}.cumulus_id`);
+        }
+        if (this.searchPdr()) {
+            query.join(pdrsTable, `${this.tableName}.pdr_cumulus_id`, `${pdrsTable}.cumulus_id`);
+        }
+    }
+    /**
+     * Aggregates the search query based on queryStringParameters
+     *
+     * @param query - the knex query to be aggregated
+     * @param knex - the knex client to be used
+     */
+    aggregateQueryField(query, knex) {
+        if (this.field?.includes('error.Error')) {
+            query.select(knex.raw("error ->> 'Error' as aggregatedfield"));
+        }
+        else {
+            query.select(`${this.tableName}.${this.field} as aggregatedfield`);
+        }
+        query.modify((queryBuilder) => this.joinTables(queryBuilder))
+            .count('* as count')
+            .groupBy('aggregatedfield')
+            .orderBy([{ column: 'count', order: 'desc' }, { column: 'aggregatedfield' }]);
+    }
+    /**
+     * Builds basic query
+     *
+     * @param knex - the knex client
+     * @returns the search query
+     */
+    buildBasicQuery(knex) {
+        const searchQuery = knex(this.tableName);
+        this.aggregateQueryField(searchQuery, knex);
+        return { searchQuery };
+    }
+    /**
+     * Builds queries for infix and prefix
+     *
+     * @param params
+     * @param params.searchQuery - the search query
+     * @param [params.dbQueryParameters] - the db query parameters
+     */
+    buildInfixPrefixQuery(params) {
+        const { searchQuery, dbQueryParameters } = params;
+        const { infix, prefix } = dbQueryParameters || this.dbQueryParameters;
+        const fieldName = infixMapping[this.tableName];
+        if (infix) {
+            searchQuery.whereLike(`${this.tableName}.${fieldName}`, `%${infix}%`);
+        }
+        if (prefix) {
+            searchQuery.whereLike(`${this.tableName}.${fieldName}`, `%${prefix}%`);
+        }
+    }
+    /**
+     * 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
+     */
+    buildTermQuery(params) {
+        const { dbQueryParameters, searchQuery } = params;
+        const { term = {} } = dbQueryParameters ?? this.dbQueryParameters;
+        if (this.field?.includes('error.Error')) {
+            searchQuery.whereRaw(`${this.tableName}.error ->> 'Error' is not null`);
+        }
+        return super.buildTermQuery({
+            ...params,
+            dbQueryParameters: { term: (0, omit_1.default)(term, 'error.Error') },
+        });
+    }
+    /**
+     * Executes the aggregate search query
+     *
+     * @param testKnex - the knex client to be used
+     * @returns the aggregate query results in api format
+     */
+    async aggregate(testKnex) {
+        const knex = testKnex ?? await (0, connection_1.getKnexClient)();
+        const { searchQuery } = this.buildSearch(knex);
+        try {
+            const pgRecords = await searchQuery;
+            return this.formatAggregateResult(pgRecords);
+        }
+        catch (error) {
+            return error;
+        }
+    }
+}
+exports.StatsSearch = StatsSearch;
+//# sourceMappingURL=StatsSearch.js.map