@cumulus/db 19.1.0 → 19.2.0-alpha.1

package/dist/search/AsyncOperationSearch.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncOperationSearch = void 0;
+const pick_1 = __importDefault(require("lodash/pick"));
+const logger_1 = __importDefault(require("@cumulus/logger"));
+const BaseSearch_1 = require("./BaseSearch");
+const async_operations_1 = require("../translate/async_operations");
+const log = new logger_1.default({ sender: '@cumulus/db/AsyncOperationSearch' });
+/**
+ * Class to build and execute db search query for asyncOperation
+ */
+class AsyncOperationSearch extends BaseSearch_1.BaseSearch {
+    constructor(event) {
+        super(event, 'asyncOperation');
+    }
+    /**
+     * 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.whereRaw(`${this.tableName}.id::text like ?`, `%${infix}%`));
+        }
+        if (prefix) {
+            [countQuery, searchQuery].forEach((query) => query.whereRaw(`${this.tableName}.id::text like ?`, `${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 { fields } = this.dbQueryParameters;
+        const apiRecords = pgRecords.map((item) => {
+            const pgAsyncOperation = item;
+            const apiRecord = (0, async_operations_1.translatePostgresAsyncOperationToApiAsyncOperation)(pgAsyncOperation);
+            return fields ? (0, pick_1.default)(apiRecord, fields) : apiRecord;
+        });
+        return apiRecords;
+    }
+}
+exports.AsyncOperationSearch = AsyncOperationSearch;
+//# sourceMappingURL=AsyncOperationSearch.js.map

package/dist/search/BaseSearch.d.ts

@@ -7,7 +7,7 @@ export declare const typeToTable: {
 /**
  * Class to build and execute db search query
  */
-declare class BaseSearch {
+declare abstract class BaseSearch {
     readonly type: string;
     readonly tableName: string;
     readonly queryStringParameters: QueryStringParameters;
@@ -19,6 +19,12 @@ declare class BaseSearch {
      * @returns whether collection search is needed
      */
     protected searchCollection(): boolean;
+    /**
+     * check if joined executions table search is needed
+     *
+     * @returns whether execution search is needed
+     */
+    protected searchExecution(): boolean;
     /**
      * check if joined pdrs table search is needed
      *
@@ -58,7 +64,7 @@ declare class BaseSearch {
      * Build basic query
      *
      * @param knex - DB client
-     * @throws - function is not implemented
+     * @returns queries for getting count and search result
      */
     protected buildBasicQuery(knex: Knex): {
         countQuery?: Knex.QueryBuilder;

package/dist/search/BaseSearch.js

@@ -19,6 +19,7 @@ exports.typeToTable = {
     pdr: tables_1.TableNames.pdrs,
     provider: tables_1.TableNames.providers,
     rule: tables_1.TableNames.rules,
+    reconciliationReport: tables_1.TableNames.reconciliationReports,
 };
 /**
  * Class to build and execute db search query
@@ -46,6 +47,15 @@ class BaseSearch {
             || terms?.collectionName
             || terms?.collectionVersion);
     }
+    /**
+     * check if joined executions table search is needed
+     *
+     * @returns whether execution search is needed
+     */
+    searchExecution() {
+        const { not, term, terms } = this.dbQueryParameters;
+        return !!(not?.executionArn || term?.executionArn || terms?.executionArn);
+    }
     /**
      * check if joined pdrs table search is needed
      *
@@ -113,11 +123,14 @@ class BaseSearch {
      * Build basic query
      *
      * @param knex - DB client
-     * @throws - function is not implemented
+     * @returns queries for getting count and search result
      */
     buildBasicQuery(knex) {
-        log.debug(`buildBasicQuery is not implemented ${knex.constructor.name}`);
-        throw new Error('buildBasicQuery is not implemented');
+        const countQuery = knex(this.tableName)
+            .count('*');
+        const searchQuery = knex(this.tableName)
+            .select(`${this.tableName}.*`);
+        return { countQuery, searchQuery };
     }
     /**
      * Build queries for infix and prefix
@@ -150,6 +163,9 @@ class BaseSearch {
                 case 'collectionVersion':
                     [countQuery, searchQuery].forEach((query) => query?.[queryMethod](`${this.tableName}.collection_cumulus_id`));
                     break;
+                case 'executionArn':
+                    [countQuery, searchQuery].forEach((query) => query?.[queryMethod](`${this.tableName}.execution_cumulus_id`));
+                    break;
                 case 'providerName':
                     [countQuery, searchQuery].forEach((query) => query?.[queryMethod](`${this.tableName}.provider_cumulus_id`));
                     break;
@@ -185,13 +201,12 @@ class BaseSearch {
         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);
+            const { gte, lte } = rangeValues;
+            if (gte) {
+                [countQuery, searchQuery].forEach((query) => query?.where(`${this.tableName}.${name}`, '>=', gte));
             }
-            if (rangeValues.lte) {
-                countQuery?.where(`${this.tableName}.${name}`, '<=', rangeValues.lte);
-                searchQuery.where(`${this.tableName}.${name}`, '<=', rangeValues.lte);
+            if (lte) {
+                [countQuery, searchQuery].forEach((query) => query?.where(`${this.tableName}.${name}`, '<=', lte));
             }
         });
     }
@@ -215,6 +230,9 @@ class BaseSearch {
                 case 'collectionVersion':
                     [countQuery, searchQuery].forEach((query) => query?.where(`${collectionsTable}.version`, value));
                     break;
+                case 'executionArn':
+                    [countQuery, searchQuery].forEach((query) => query?.where(`${executionsTable}.arn`, value));
+                    break;
                 case 'providerName':
                     [countQuery, searchQuery].forEach((query) => query?.where(`${providersTable}.name`, value));
                     break;
@@ -223,7 +241,7 @@ class BaseSearch {
                     break;
                 case 'error.Error':
                     [countQuery, searchQuery]
-                        .forEach((query) => query?.whereRaw(`${this.tableName}.error->>'Error' = '${value}'`));
+                        .forEach((query) => value && query?.whereRaw(`${this.tableName}.error->>'Error' = ?`, value));
                     break;
                 case 'asyncOperationId':
                     [countQuery, searchQuery].forEach((query) => query?.where(`${asyncOperationsTable}.id`, value));
@@ -265,6 +283,9 @@ class BaseSearch {
         }
         Object.entries((0, omit_1.default)(terms, ['collectionName', 'collectionVersion'])).forEach(([name, value]) => {
             switch (name) {
+                case 'executionArn':
+                    [countQuery, searchQuery].forEach((query) => query?.whereIn(`${executionsTable}.arn`, value));
+                    break;
                 case 'providerName':
                     [countQuery, searchQuery].forEach((query) => query?.whereIn(`${providersTable}.name`, value));
                     break;
@@ -273,7 +294,7 @@ class BaseSearch {
                     break;
                 case 'error.Error':
                     [countQuery, searchQuery]
-                        .forEach((query) => query?.whereRaw(`${this.tableName}.error->>'Error' in ('${value.join('\',\'')}')`));
+                        .forEach((query) => query?.whereRaw(`${this.tableName}.error->>'Error' in (${value.map(() => '?').join(',')})`, [...value]));
                     break;
                 case 'asyncOperationId':
                     [countQuery, searchQuery].forEach((query) => query?.whereIn(`${asyncOperationsTable}.id`, value));
@@ -308,6 +329,9 @@ class BaseSearch {
         }
         Object.entries((0, omit_1.default)(term, ['collectionName', 'collectionVersion'])).forEach(([name, value]) => {
             switch (name) {
+                case 'executionArn':
+                    [countQuery, searchQuery].forEach((query) => query?.whereNot(`${executionsTable}.arn`, value));
+                    break;
                 case 'providerName':
                     [countQuery, searchQuery].forEach((query) => query?.whereNot(`${providersTable}.name`, value));
                     break;
@@ -321,7 +345,7 @@ class BaseSearch {
                     [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}'`));
+                    [countQuery, searchQuery].forEach((query) => value && query?.whereRaw(`${this.tableName}.error->>'Error' != ?`, value));
                     break;
                 default:
                     [countQuery, searchQuery].forEach((query) => query?.whereNot(`${this.tableName}.${name}`, value));
@@ -343,6 +367,9 @@ class BaseSearch {
             if (key.column.startsWith('error')) {
                 searchQuery.orderByRaw(`${this.tableName}.error ->> 'Error' ${key.order}`);
             }
+            else if (dbQueryParameters?.collate) {
+                searchQuery.orderByRaw(`${key} collate \"${dbQueryParameters.collate}\"`);
+            }
             else {
                 searchQuery.orderBy([key]);
             }
@@ -369,7 +396,7 @@ class BaseSearch {
      */
     async getEstimatedRowcount(params) {
         const { knex, tableName = this.tableName } = params;
-        const query = knex.raw(`EXPLAIN (FORMAT JSON) select * from "${tableName}"`);
+        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"]';

package/dist/search/CollectionSearch.d.ts

@@ -20,16 +20,6 @@ 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
      *
@@ -44,20 +34,23 @@ export declare class CollectionSearch extends BaseSearch {
         dbQueryParameters?: DbQueryParameters;
     }): void;
     /**
-     * Build queries for range fields
+     * Build subquery for active collections
+     * The subquery will search granules
      *
-     * @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
+     * @param knex - db client
+     * @returns granule query
      */
-    protected buildRangeQuery(params: {
-        knex: Knex;
-        countQuery: Knex.QueryBuilder;
+    private buildSubQueryForActiveCollections;
+    /**
+     * Build the search query
+     *
+     * @param knex - DB client
+     * @returns queries for getting count and search result
+     */
+    protected buildSearch(knex: Knex): {
+        countQuery?: Knex.QueryBuilder;
         searchQuery: Knex.QueryBuilder;
-        dbQueryParameters?: DbQueryParameters;
-    }): void;
+    };
     /**
      * Executes stats query to get granules' status aggregation
      *

package/dist/search/CollectionSearch.js

@@ -4,12 +4,17 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CollectionSearch = void 0;
+const omitBy_1 = __importDefault(require("lodash/omitBy"));
 const pick_1 = __importDefault(require("lodash/pick"));
 const logger_1 = __importDefault(require("@cumulus/logger"));
 const BaseSearch_1 = require("./BaseSearch");
+const queries_1 = require("./queries");
+const GranuleSearch_1 = require("./GranuleSearch");
 const collections_1 = require("../translate/collections");
 const tables_1 = require("../tables");
 const log = new logger_1.default({ sender: '@cumulus/db/CollectionSearch' });
+const granuleFields = ['createdAt', 'granuleId', 'timestamp', 'updatedAt'];
+const isGranuleField = (_value, key) => granuleFields.includes(key.split('__')[0]);
 /**
  * Class to build and execute db search query for collections
  */
@@ -19,19 +24,10 @@ class CollectionSearch extends BaseSearch_1.BaseSearch {
         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 };
+        // for active collection search, omit the fields which are for searching granules
+        if (this.active) {
+            this.dbQueryParameters = (0, queries_1.convertQueryStringToDbQueryParameters)(this.type, (0, omitBy_1.default)(this.queryStringParameters, isGranuleField));
+        }
     }
     /**
      * Build queries for infix and prefix
@@ -48,38 +44,43 @@ class CollectionSearch extends BaseSearch_1.BaseSearch {
             [countQuery, searchQuery].forEach((query) => query.whereLike(`${this.tableName}.name`, `%${infix}%`));
         }
         if (prefix) {
-            [countQuery, searchQuery].forEach((query) => query.whereLike(`${this.tableName}.name`, `%${prefix}%`));
+            [countQuery, searchQuery].forEach((query) => query.whereLike(`${this.tableName}.name`, `${prefix}%`));
         }
     }
     /**
-     * Build queries for range fields
+     * Build subquery for active collections
+     * The subquery will search granules
      *
-     * @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
+     * @param knex - db client
+     * @returns granule query
+     */
+    buildSubQueryForActiveCollections(knex) {
+        const granulesTable = tables_1.TableNames.granules;
+        const granuleSearch = new GranuleSearch_1.GranuleSearch({ queryStringParameters: this.queryStringParameters });
+        const { countQuery: subQuery } = granuleSearch.buildSearchForActiveCollections(knex);
+        subQuery
+            .clear('select')
+            .select(1)
+            .where(`${granulesTable}.collection_cumulus_id`, knex.raw(`${this.tableName}.cumulus_id`))
+            .limit(1);
+        return subQuery;
+    }
+    /**
+     * Build the search query
+     *
+     * @param knex - DB client
+     * @returns queries for getting count and search result
      */
-    buildRangeQuery(params) {
+    buildSearch(knex) {
+        const queries = super.buildSearch(knex);
         if (!this.active) {
-            super.buildRangeQuery(params);
-            return;
+            return queries;
         }
-        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));
+        const subQuery = this.buildSubQueryForActiveCollections(knex);
+        const { countQuery, searchQuery } = queries;
+        [countQuery, searchQuery].forEach((query) => query?.whereExists(subQuery));
+        log.debug(`buildSearch returns countQuery: ${countQuery?.toSQL().sql}, searchQuery: ${searchQuery.toSQL().sql}`);
+        return { countQuery, searchQuery };
     }
     /**
      * Executes stats query to get granules' status aggregation
@@ -90,21 +91,19 @@ class CollectionSearch extends BaseSearch_1.BaseSearch {
      */
     async retrieveGranuleStats(collectionCumulusIds, knex) {
         const granulesTable = tables_1.TableNames.granules;
-        const statsQuery = knex(granulesTable)
+        let statsQuery = knex(granulesTable);
+        if (this.active) {
+            const granuleSearch = new GranuleSearch_1.GranuleSearch({
+                queryStringParameters: this.queryStringParameters,
+            });
+            const { countQuery } = granuleSearch.buildSearchForActiveCollections(knex);
+            statsQuery = countQuery.clear('select');
+        }
+        statsQuery
             .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) => {
@@ -133,6 +132,7 @@ class CollectionSearch extends BaseSearch_1.BaseSearch {
      */
     async translatePostgresRecordsToApiRecords(pgRecords, knex) {
         log.debug(`translatePostgresRecordsToApiRecords number of records ${pgRecords.length} `);
+        const { fields } = this.dbQueryParameters;
         let statsRecords;
         const cumulusIds = pgRecords.map((record) => record.cumulus_id);
         if (this.includeStats) {
@@ -140,9 +140,7 @@ class CollectionSearch extends BaseSearch_1.BaseSearch {
         }
         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;
+            const apiRecordFinal = fields ? (0, pick_1.default)(apiRecord, fields) : apiRecord;
             if (statsRecords) {
                 apiRecordFinal.stats = statsRecords[record.cumulus_id] ? statsRecords[record.cumulus_id]
                     : {

package/dist/search/ExecutionSearch.d.ts

@@ -16,15 +16,15 @@ interface ExecutionRecord extends BaseRecord, PostgresExecutionRecord {
 export declare class ExecutionSearch extends BaseSearch {
     constructor(event: QueryEvent);
     /**
-     * check if joined async_ops table search is needed
+     * check if joined async_operations table search is needed
      *
-     * @returns whether collection search is needed
+     * @returns whether async_operations search is needed
      */
     protected searchAsync(): boolean;
     /**
-     * check if joined async_ops table search is needed
+     * check if joined parent execution table search is needed
      *
-     * @returns whether collection search is needed
+     * @returns whether parent execution search is needed
      */
     protected searchParent(): boolean;
     /**

package/dist/search/ExecutionSearch.js

@@ -24,18 +24,18 @@ class ExecutionSearch extends BaseSearch_1.BaseSearch {
         super(event, 'execution');
     }
     /**
-     * check if joined async_ops table search is needed
+     * check if joined async_operations table search is needed
      *
-     * @returns whether collection search is needed
+     * @returns whether async_operations 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
+     * check if joined parent execution table search is needed
      *
-     * @returns whether collection search is needed
+     * @returns whether parent execution search is needed
      */
     searchParent() {
         const { not, term, terms } = this.dbQueryParameters;
@@ -101,7 +101,7 @@ class ExecutionSearch extends BaseSearch_1.BaseSearch {
             [countQuery, searchQuery].forEach((query) => query.whereLike(`${this.tableName}.arn`, `%${infix}%`));
         }
         if (prefix) {
-            [countQuery, searchQuery].forEach((query) => query.whereLike(`${this.tableName}.arn`, `%${prefix}%`));
+            [countQuery, searchQuery].forEach((query) => query.whereLike(`${this.tableName}.arn`, `${prefix}%`));
         }
     }
     /**
@@ -112,6 +112,7 @@ class ExecutionSearch extends BaseSearch_1.BaseSearch {
      */
     translatePostgresRecordsToApiRecords(pgRecords) {
         log.debug(`translatePostgresRecordsToApiRecords number of records ${pgRecords.length} `);
+        const { fields } = this.dbQueryParameters;
         const apiRecords = pgRecords.map((executionRecord) => {
             const { collectionName, collectionVersion, asyncOperationId, parentArn } = executionRecord;
             const collectionId = collectionName && collectionVersion
@@ -122,9 +123,7 @@ class ExecutionSearch extends BaseSearch_1.BaseSearch {
                 asyncOperationId,
                 parentArn,
             });
-            return this.dbQueryParameters.fields
-                ? (0, pick_1.default)(apiRecord, this.dbQueryParameters.fields)
-                : apiRecord;
+            return fields ? (0, pick_1.default)(apiRecord, fields) : apiRecord;
         });
         return apiRecords;
     }

package/dist/search/GranuleSearch.d.ts

@@ -5,14 +5,9 @@ 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;
 }
 /**
@@ -43,13 +38,26 @@ export declare class GranuleSearch extends BaseSearch {
         searchQuery: Knex.QueryBuilder;
         dbQueryParameters?: DbQueryParameters;
     }): void;
+    /**
+     * Build the search query for active collections.
+     * If time params are specified the query will search granules that have been updated
+     * in that time frame.  If granuleId or providerId are provided, it will filter those as well.
+     *
+     * @param knex - DB client
+     * @returns queries for getting count and search result
+     */
+    buildSearchForActiveCollections(knex: Knex): {
+        countQuery: Knex.QueryBuilder;
+        searchQuery: Knex.QueryBuilder;
+    };
     /**
      * Translate postgres records to api records
      *
      * @param pgRecords - postgres records returned from query
+     * @param knex - DB client
      * @returns translated api records
      */
-    protected translatePostgresRecordsToApiRecords(pgRecords: GranuleRecord[]): Partial<ApiGranuleRecord>[];
+    protected translatePostgresRecordsToApiRecords(pgRecords: GranuleRecord[], knex: Knex): Promise<Partial<ApiGranuleRecord>[]>;
 }
 export {};
 //# sourceMappingURL=GranuleSearch.d.ts.map

package/dist/search/GranuleSearch.js

@@ -10,6 +10,8 @@ const logger_1 = __importDefault(require("@cumulus/logger"));
 const BaseSearch_1 = require("./BaseSearch");
 const granules_1 = require("../translate/granules");
 const tables_1 = require("../tables");
+const file_1 = require("../models/file");
+const execution_1 = require("../lib/execution");
 const log = new logger_1.default({ sender: '@cumulus/db/GranuleSearch' });
 /**
  * Class to build and execute db search query for granules
@@ -78,14 +80,56 @@ class GranuleSearch extends BaseSearch_1.BaseSearch {
             [countQuery, searchQuery].forEach((query) => query.whereLike(`${this.tableName}.granule_id`, `${prefix}%`));
         }
     }
+    /**
+     * Build the search query for active collections.
+     * If time params are specified the query will search granules that have been updated
+     * in that time frame.  If granuleId or providerId are provided, it will filter those as well.
+     *
+     * @param knex - DB client
+     * @returns queries for getting count and search result
+     */
+    buildSearchForActiveCollections(knex) {
+        const { countQuery, searchQuery } = this.buildBasicQuery(knex);
+        this.buildTermQuery({ countQuery, searchQuery });
+        this.buildTermsQuery({ countQuery, searchQuery });
+        this.buildRangeQuery({ knex, countQuery, searchQuery });
+        log.debug(`buildSearchForActiveCollections returns countQuery: ${countQuery?.toSQL().sql}, searchQuery: ${searchQuery.toSQL().sql}`);
+        return { countQuery, searchQuery };
+    }
     /**
      * Translate postgres records to api records
      *
      * @param pgRecords - postgres records returned from query
+     * @param knex - DB client
      * @returns translated api records
      */
-    translatePostgresRecordsToApiRecords(pgRecords) {
+    async translatePostgresRecordsToApiRecords(pgRecords, knex) {
         log.debug(`translatePostgresRecordsToApiRecords number of records ${pgRecords.length} `);
+        const { fields, includeFullRecord } = this.dbQueryParameters;
+        const fileMapping = {};
+        const executionMapping = {};
+        const cumulusIds = pgRecords.map((record) => record.cumulus_id);
+        if (includeFullRecord) {
+            //get Files
+            const fileModel = new file_1.FilePgModel();
+            const files = await fileModel.searchByGranuleCumulusIds(knex, cumulusIds);
+            files.forEach((file) => {
+                if (!(file.granule_cumulus_id in fileMapping)) {
+                    fileMapping[file.granule_cumulus_id] = [];
+                }
+                fileMapping[file.granule_cumulus_id].push(file);
+            });
+            //get Executions
+            const executions = await (0, execution_1.getExecutionInfoByGranuleCumulusIds)({
+                knexOrTransaction: knex,
+                granuleCumulusIds: cumulusIds,
+            });
+            executions.forEach((execution) => {
+                if (!(execution.granule_cumulus_id in executionMapping)) {
+                    executionMapping[execution.granule_cumulus_id] = execution;
+                }
+            });
+        }
         const apiRecords = pgRecords.map((item) => {
             const granulePgRecord = item;
             const collectionPgRecord = {
@@ -93,14 +137,21 @@ class GranuleSearch extends BaseSearch_1.BaseSearch {
                 name: item.collectionName,
                 version: item.collectionVersion,
             };
+            const executionUrls = executionMapping[item.cumulus_id]?.url
+                ? [{ url: executionMapping[item.cumulus_id].url }]
+                : [];
             const pdr = item.pdrName ? { name: item.pdrName } : undefined;
             const providerPgRecord = item.providerName ? { name: item.providerName } : undefined;
+            const fileRecords = fileMapping[granulePgRecord.cumulus_id] || [];
             const apiRecord = (0, granules_1.translatePostgresGranuleToApiGranuleWithoutDbQuery)({
-                granulePgRecord, collectionPgRecord, pdr, providerPgRecord,
+                granulePgRecord,
+                collectionPgRecord,
+                pdr,
+                providerPgRecord,
+                files: fileRecords,
+                executionUrls,
             });
-            return this.dbQueryParameters.fields
-                ? (0, pick_1.default)(apiRecord, this.dbQueryParameters.fields)
-                : apiRecord;
+            return fields ? (0, pick_1.default)(apiRecord, fields) : apiRecord;
         });
         return apiRecords;
     }