@cumulus/db 18.4.0 → 19.0.0

package/dist/search/BaseSearch.js

@@ -0,0 +1,416 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseSearch = exports.typeToTable = void 0;
+const get_1 = __importDefault(require("lodash/get"));
+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 queries_1 = require("./queries");
+const log = new logger_1.default({ sender: '@cumulus/db/BaseSearch' });
+exports.typeToTable = {
+    asyncOperation: tables_1.TableNames.asyncOperations,
+    collection: tables_1.TableNames.collections,
+    execution: tables_1.TableNames.executions,
+    granule: tables_1.TableNames.granules,
+    pdr: tables_1.TableNames.pdrs,
+    provider: tables_1.TableNames.providers,
+    rule: tables_1.TableNames.rules,
+};
+/**
+ * Class to build and execute db search query
+ */
+class BaseSearch {
+    constructor(event, type) {
+        // parsed from queryStringParameters for query build
+        this.dbQueryParameters = {};
+        this.type = type;
+        this.tableName = exports.typeToTable[this.type];
+        this.queryStringParameters = event?.queryStringParameters ?? {};
+        this.dbQueryParameters = (0, queries_1.convertQueryStringToDbQueryParameters)(this.type, this.queryStringParameters);
+    }
+    /**
+     * check if joined collections table search is needed
+     *
+     * @returns whether collection search is needed
+     */
+    searchCollection() {
+        const { not, term, terms } = this.dbQueryParameters;
+        return !!(not?.collectionName
+            || not?.collectionVersion
+            || term?.collectionName
+            || term?.collectionVersion
+            || terms?.collectionName
+            || terms?.collectionVersion);
+    }
+    /**
+     * check if joined pdrs table search is needed
+     *
+     * @returns whether pdr search is needed
+     */
+    searchPdr() {
+        const { not, term, terms } = this.dbQueryParameters;
+        return !!(not?.pdrName || term?.pdrName || terms?.pdrName);
+    }
+    /**
+     * check if joined providers table search is needed
+     *
+     * @returns whether provider search is needed
+     */
+    searchProvider() {
+        const { not, term, terms } = this.dbQueryParameters;
+        return !!(not?.providerName || term?.providerName || terms?.providerName);
+    }
+    /**
+     * Determine if an estimated row count should be returned
+     *
+     * @param countSql - sql statement for count
+     * @returns whether an estimated row count should be returned
+     */
+    shouldEstimateRowcount(countSql) {
+        const isBasicQuery = (countSql === `select count(*) from "${this.tableName}"`);
+        return this.dbQueryParameters.estimateTableRowCount === true && isBasicQuery;
+    }
+    /**
+     * Build the search query
+     *
+     * @param knex - DB client
+     * @returns queries for getting count and search result
+     */
+    buildSearch(knex) {
+        const { countQuery, searchQuery } = this.buildBasicQuery(knex);
+        this.buildTermQuery({ countQuery, searchQuery });
+        this.buildTermsQuery({ countQuery, searchQuery });
+        this.buildNotMatchQuery({ countQuery, searchQuery });
+        this.buildRangeQuery({ knex, countQuery, searchQuery });
+        this.buildExistsQuery({ countQuery, searchQuery });
+        this.buildInfixPrefixQuery({ countQuery, searchQuery });
+        this.buildSortQuery({ searchQuery });
+        const { limit, offset } = this.dbQueryParameters;
+        if (limit)
+            searchQuery.limit(limit);
+        if (offset)
+            searchQuery.offset(offset);
+        log.debug(`buildSearch returns countQuery: ${countQuery?.toSQL().sql}, searchQuery: ${searchQuery.toSQL().sql}`);
+        return { countQuery, searchQuery };
+    }
+    /**
+     * Get metadata template for query result
+     *
+     * @returns metadata template
+     */
+    _metaTemplate() {
+        return {
+            name: 'cumulus-api',
+            stack: process.env.stackName,
+            table: this.tableName,
+        };
+    }
+    /**
+     * Build basic query
+     *
+     * @param knex - DB client
+     * @throws - function is not implemented
+     */
+    buildBasicQuery(knex) {
+        log.debug(`buildBasicQuery is not implemented ${knex.constructor.name}`);
+        throw new Error('buildBasicQuery is not implemented');
+    }
+    /**
+     * 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) {
+        log.debug(`buildInfixPrefixQuery is not implemented ${Object.keys(params)}`);
+        throw new Error('buildInfixPrefixQuery is not implemented');
+    }
+    /**
+     * Build queries for checking if field 'exists'
+     *
+     * @param params
+     * @param [params.countQuery] - query builder for getting count
+     * @param params.searchQuery - query builder for search
+     * @param [params.dbQueryParameters] - db query parameters
+     */
+    buildExistsQuery(params) {
+        const { countQuery, searchQuery, dbQueryParameters } = params;
+        const { exists = {} } = dbQueryParameters ?? this.dbQueryParameters;
+        Object.entries(exists).forEach(([name, value]) => {
+            const queryMethod = value ? 'whereNotNull' : 'whereNull';
+            const checkNull = value ? 'not null' : 'null';
+            switch (name) {
+                case 'collectionName':
+                case 'collectionVersion':
+                    [countQuery, searchQuery].forEach((query) => query?.[queryMethod](`${this.tableName}.collection_cumulus_id`));
+                    break;
+                case 'providerName':
+                    [countQuery, searchQuery].forEach((query) => query?.[queryMethod](`${this.tableName}.provider_cumulus_id`));
+                    break;
+                case 'pdrName':
+                    [countQuery, searchQuery].forEach((query) => query?.[queryMethod](`${this.tableName}.pdr_cumulus_id`));
+                    break;
+                case 'asyncOperationId':
+                    [countQuery, searchQuery].forEach((query) => query?.[queryMethod](`${this.tableName}.async_operation_cumulus_id`));
+                    break;
+                case 'error':
+                case 'error.Error':
+                    [countQuery, searchQuery].forEach((query) => query?.whereRaw(`${this.tableName}.error ->> 'Error' is ${checkNull}`));
+                    break;
+                case 'parentArn':
+                    [countQuery, searchQuery].forEach((query) => query?.[queryMethod](`${this.tableName}.parent_cumulus_id`));
+                    break;
+                default:
+                    [countQuery, searchQuery].forEach((query) => query?.[queryMethod](`${this.tableName}.${name}`));
+                    break;
+            }
+        });
+    }
+    /**
+     * 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) {
+        const { countQuery, searchQuery, dbQueryParameters } = params;
+        const { range = {} } = dbQueryParameters ?? this.dbQueryParameters;
+        Object.entries(range).forEach(([name, rangeValues]) => {
+            if (rangeValues.gte) {
+                countQuery?.where(`${this.tableName}.${name}`, '>=', rangeValues.gte);
+                searchQuery.where(`${this.tableName}.${name}`, '>=', rangeValues.gte);
+            }
+            if (rangeValues.lte) {
+                countQuery?.where(`${this.tableName}.${name}`, '<=', rangeValues.lte);
+                searchQuery.where(`${this.tableName}.${name}`, '<=', rangeValues.lte);
+            }
+        });
+    }
+    /**
+     * Build queries for term fields
+     *
+     * @param params
+     * @param [params.countQuery] - query builder for getting count
+     * @param params.searchQuery - query builder for search
+     * @param [params.dbQueryParameters] - db query parameters
+     */
+    buildTermQuery(params) {
+        const { collections: collectionsTable, providers: providersTable, pdrs: pdrsTable, asyncOperations: asyncOperationsTable, executions: executionsTable, } = tables_1.TableNames;
+        const { countQuery, searchQuery, dbQueryParameters } = params;
+        const { term = {} } = dbQueryParameters ?? this.dbQueryParameters;
+        Object.entries(term).forEach(([name, value]) => {
+            switch (name) {
+                case 'collectionName':
+                    [countQuery, searchQuery].forEach((query) => query?.where(`${collectionsTable}.name`, value));
+                    break;
+                case 'collectionVersion':
+                    [countQuery, searchQuery].forEach((query) => query?.where(`${collectionsTable}.version`, value));
+                    break;
+                case 'providerName':
+                    [countQuery, searchQuery].forEach((query) => query?.where(`${providersTable}.name`, value));
+                    break;
+                case 'pdrName':
+                    [countQuery, searchQuery].forEach((query) => query?.where(`${pdrsTable}.name`, value));
+                    break;
+                case 'error.Error':
+                    [countQuery, searchQuery]
+                        .forEach((query) => query?.whereRaw(`${this.tableName}.error->>'Error' = '${value}'`));
+                    break;
+                case 'asyncOperationId':
+                    [countQuery, searchQuery].forEach((query) => query?.where(`${asyncOperationsTable}.id`, value));
+                    break;
+                case 'parentArn':
+                    [countQuery, searchQuery].forEach((query) => query?.where(`${executionsTable}_parent.arn`, value));
+                    break;
+                default:
+                    [countQuery, searchQuery].forEach((query) => query?.where(`${this.tableName}.${name}`, value));
+                    break;
+            }
+        });
+    }
+    /**
+     * Build queries for terms fields
+     *
+     * @param params
+     * @param [params.countQuery] - query builder for getting count
+     * @param params.searchQuery - query builder for search
+     * @param [params.dbQueryParameters] - db query parameters
+     */
+    buildTermsQuery(params) {
+        const { collections: collectionsTable, providers: providersTable, pdrs: pdrsTable, asyncOperations: asyncOperationsTable, executions: executionsTable, } = tables_1.TableNames;
+        const { countQuery, searchQuery, dbQueryParameters } = params;
+        const { terms = {} } = dbQueryParameters ?? this.dbQueryParameters;
+        // collection name and version are searched in pair
+        if (terms.collectionName && terms.collectionVersion
+            && terms.collectionName.length > 0
+            && terms.collectionVersion.length > 0) {
+            const collectionPair = [];
+            for (let i = 0; i < terms.collectionName.length; i += 1) {
+                const name = terms.collectionName[i];
+                const version = terms.collectionVersion[i];
+                if (name && version)
+                    collectionPair.push([name, version]);
+            }
+            [countQuery, searchQuery]
+                .forEach((query) => query?.whereIn([`${collectionsTable}.name`, `${collectionsTable}.version`], collectionPair));
+        }
+        Object.entries((0, omit_1.default)(terms, ['collectionName', 'collectionVersion'])).forEach(([name, value]) => {
+            switch (name) {
+                case 'providerName':
+                    [countQuery, searchQuery].forEach((query) => query?.whereIn(`${providersTable}.name`, value));
+                    break;
+                case 'pdrName':
+                    [countQuery, searchQuery].forEach((query) => query?.whereIn(`${pdrsTable}.name`, value));
+                    break;
+                case 'error.Error':
+                    [countQuery, searchQuery]
+                        .forEach((query) => query?.whereRaw(`${this.tableName}.error->>'Error' in ('${value.join('\',\'')}')`));
+                    break;
+                case 'asyncOperationId':
+                    [countQuery, searchQuery].forEach((query) => query?.whereIn(`${asyncOperationsTable}.id`, value));
+                    break;
+                case 'parentArn':
+                    [countQuery, searchQuery].forEach((query) => query?.whereIn(`${executionsTable}_parent.arn`, value));
+                    break;
+                default:
+                    [countQuery, searchQuery].forEach((query) => query?.whereIn(`${this.tableName}.${name}`, value));
+                    break;
+            }
+        });
+    }
+    /**
+     * Build queries for checking if field doesn't match the given value
+     *
+     * @param params
+     * @param [params.countQuery] - query builder for getting count
+     * @param params.searchQuery - query builder for search
+     * @param [params.dbQueryParameters] - db query parameters
+     */
+    buildNotMatchQuery(params) {
+        const { collections: collectionsTable, providers: providersTable, pdrs: pdrsTable, asyncOperations: asyncOperationsTable, executions: executionsTable, } = tables_1.TableNames;
+        const { countQuery, searchQuery, dbQueryParameters } = params;
+        const { not: term = {} } = dbQueryParameters ?? this.dbQueryParameters;
+        // collection name and version are searched in pair
+        if (term.collectionName && term.collectionVersion) {
+            [countQuery, searchQuery].forEach((query) => query?.whereNot({
+                [`${collectionsTable}.name`]: term.collectionName,
+                [`${collectionsTable}.version`]: term.collectionVersion,
+            }));
+        }
+        Object.entries((0, omit_1.default)(term, ['collectionName', 'collectionVersion'])).forEach(([name, value]) => {
+            switch (name) {
+                case 'providerName':
+                    [countQuery, searchQuery].forEach((query) => query?.whereNot(`${providersTable}.name`, value));
+                    break;
+                case 'pdrName':
+                    [countQuery, searchQuery].forEach((query) => query?.whereNot(`${pdrsTable}.name`, value));
+                    break;
+                case 'asyncOperationId':
+                    [countQuery, searchQuery].forEach((query) => query?.whereNot(`${asyncOperationsTable}.id`, value));
+                    break;
+                case 'parentArn':
+                    [countQuery, searchQuery].forEach((query) => query?.whereNot(`${executionsTable}_parent.arn`, value));
+                    break;
+                case 'error.Error':
+                    [countQuery, searchQuery].forEach((query) => query?.whereRaw(`${this.tableName}.error->>'Error' != '${value}'`));
+                    break;
+                default:
+                    [countQuery, searchQuery].forEach((query) => query?.whereNot(`${this.tableName}.${name}`, value));
+                    break;
+            }
+        });
+    }
+    /**
+     * Build queries for sort keys and fields
+     *
+     * @param params
+     * @param params.searchQuery - query builder for search
+     * @param [params.dbQueryParameters] - db query parameters
+     */
+    buildSortQuery(params) {
+        const { searchQuery, dbQueryParameters } = params;
+        const { sort } = dbQueryParameters || this.dbQueryParameters;
+        sort?.forEach((key) => {
+            if (key.column.startsWith('error')) {
+                searchQuery.orderByRaw(`${this.tableName}.error ->> 'Error' ${key.order}`);
+            }
+            else {
+                searchQuery.orderBy([key]);
+            }
+        });
+    }
+    /**
+     * Translate postgres records to api records
+     *
+     * @param pgRecords - postgres records returned from query
+     * @param [knex] - knex client for additional queries if neccessary
+     * @throws - function is not implemented
+     */
+    translatePostgresRecordsToApiRecords(pgRecords, knex) {
+        log.error(`translatePostgresRecordsToApiRecords is not implemented ${pgRecords[0]} with client ${knex}`);
+        throw new Error('translatePostgresRecordsToApiRecords is not implemented');
+    }
+    /**
+     * Get estimated table rowcount
+     *
+     * @param params
+     * @param params.knex - DB client
+     * @param [params.tableName] - table name
+     * @returns rowcount
+     */
+    async getEstimatedRowcount(params) {
+        const { knex, tableName = this.tableName } = params;
+        const query = knex.raw(`EXPLAIN (FORMAT JSON) select * from "${tableName}"`);
+        log.debug(`Estimating the row count ${query.toSQL().sql}`);
+        const countResult = await query;
+        const countPath = 'rows[0]["QUERY PLAN"][0].Plan["Plan Rows"]';
+        const estimatedCount = (0, get_1.default)(countResult, countPath);
+        const count = Number(estimatedCount ?? 0);
+        return count;
+    }
+    /**
+     * Build and execute search query
+     *
+     * @param testKnex - knex for testing
+     * @returns search result
+     */
+    async query(testKnex) {
+        const knex = testKnex ?? await (0, connection_1.getKnexClient)();
+        const { countQuery, searchQuery } = this.buildSearch(knex);
+        const shouldEstimateRowcount = countQuery
+            ? this.shouldEstimateRowcount(countQuery?.toSQL().sql)
+            : false;
+        const getEstimate = shouldEstimateRowcount
+            ? this.getEstimatedRowcount({ knex })
+            : undefined;
+        try {
+            const [countResult, pgRecords] = await Promise.all([
+                getEstimate || countQuery, searchQuery,
+            ]);
+            const meta = this._metaTemplate();
+            meta.limit = this.dbQueryParameters.limit;
+            meta.page = this.dbQueryParameters.page;
+            meta.count = shouldEstimateRowcount ? countResult : Number(countResult[0]?.count ?? 0);
+            const apiRecords = await this.translatePostgresRecordsToApiRecords(pgRecords, knex);
+            return {
+                meta,
+                results: apiRecords,
+            };
+        }
+        catch (error) {
+            log.error(`Error caught in search query for ${JSON.stringify(this.queryStringParameters)}`, error);
+            return error;
+        }
+    }
+}
+exports.BaseSearch = BaseSearch;
+//# sourceMappingURL=BaseSearch.js.map

package/dist/search/CollectionSearch.d.ts

@@ -0,0 +1,79 @@
+import { Knex } from 'knex';
+import { CollectionRecord } from '@cumulus/types/api/collections';
+import { BaseSearch } from './BaseSearch';
+import { DbQueryParameters, QueryEvent } from '../types/search';
+import { PostgresCollectionRecord } from '../types/collection';
+declare type Statuses = {
+    queued: number;
+    completed: number;
+    failed: number;
+    running: number;
+    total: number;
+};
+interface CollectionRecordApi extends CollectionRecord {
+    stats?: Statuses;
+}
+/**
+ * Class to build and execute db search query for collections
+ */
+export declare class CollectionSearch extends BaseSearch {
+    readonly active: boolean;
+    readonly includeStats: boolean;
+    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;
+    /**
+     * 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
+     */
+    protected buildRangeQuery(params: {
+        knex: Knex;
+        countQuery: Knex.QueryBuilder;
+        searchQuery: Knex.QueryBuilder;
+        dbQueryParameters?: DbQueryParameters;
+    }): void;
+    /**
+     * 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
+     */
+    private retrieveGranuleStats;
+    /**
+     * 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
+     */
+    protected translatePostgresRecordsToApiRecords(pgRecords: PostgresCollectionRecord[], knex: Knex): Promise<Partial<CollectionRecordApi>[]>;
+}
+export {};
+//# sourceMappingURL=CollectionSearch.d.ts.map

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