@cumulus/db 19.1.0 → 19.2.0-alpha.1

package/dist/search/PdrSearch.d.ts

@@ -0,0 +1,50 @@
+import { Knex } from 'knex';
+import { ApiPdrRecord } from '@cumulus/types/api/pdrs';
+import { BaseRecord } from '../types/base';
+import { BaseSearch } from './BaseSearch';
+import { DbQueryParameters, QueryEvent } from '../types/search';
+import { PostgresPdrRecord } from '../types/pdr';
+interface PdrRecord extends BaseRecord, PostgresPdrRecord {
+    collectionName: string;
+    collectionVersion: string;
+    executionArn?: string;
+    providerName: string;
+}
+/**
+ * Class to build and execute db search query for PDRs
+ */
+export declare class PdrSearch 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: PdrRecord[]): Partial<ApiPdrRecord>[];
+}
+export {};
+//# sourceMappingURL=PdrSearch.d.ts.map

package/dist/search/PdrSearch.js

@@ -0,0 +1,100 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PdrSearch = void 0;
+const pick_1 = __importDefault(require("lodash/pick"));
+const logger_1 = __importDefault(require("@cumulus/logger"));
+const BaseSearch_1 = require("./BaseSearch");
+const pdr_1 = require("../translate/pdr");
+const tables_1 = require("../tables");
+const log = new logger_1.default({ sender: '@cumulus/db/PdrSearch' });
+/**
+ * Class to build and execute db search query for PDRs
+ */
+class PdrSearch extends BaseSearch_1.BaseSearch {
+    constructor(event) {
+        super(event, 'pdr');
+    }
+    /**
+     * Build basic query
+     *
+     * @param knex - DB client
+     * @returns queries for getting count and search result
+     */
+    buildBasicQuery(knex) {
+        const { collections: collectionsTable, providers: providersTable, executions: executionsTable, } = 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`,
+            executionArn: `${executionsTable}.arn`,
+        })
+            .innerJoin(collectionsTable, `${this.tableName}.collection_cumulus_id`, `${collectionsTable}.cumulus_id`)
+            .innerJoin(providersTable, `${this.tableName}.provider_cumulus_id`, `${providersTable}.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`);
+        }
+        if (this.searchExecution()) {
+            countQuery.innerJoin(executionsTable, `${this.tableName}.execution_cumulus_id`, `${executionsTable}.cumulus_id`);
+            searchQuery.innerJoin(executionsTable, `${this.tableName}.execution_cumulus_id`, `${executionsTable}.cumulus_id`);
+        }
+        else {
+            searchQuery.leftJoin(executionsTable, `${this.tableName}.execution_cumulus_id`, `${executionsTable}.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}.name`, `%${infix}%`));
+        }
+        if (prefix) {
+            [countQuery, searchQuery].forEach((query) => query.whereLike(`${this.tableName}.name`, `${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 pdrPgRecord = item;
+            const collectionPgRecord = {
+                cumulus_id: item.collection_cumulus_id,
+                name: item.collectionName,
+                version: item.collectionVersion,
+            };
+            const providerPgRecord = { name: item.providerName };
+            const executionArn = item.executionArn;
+            const apiRecord = (0, pdr_1.translatePostgresPdrToApiPdrWithoutDbQuery)({
+                pdrPgRecord, collectionPgRecord, executionArn, providerPgRecord,
+            });
+            return fields ? (0, pick_1.default)(apiRecord, fields) : apiRecord;
+        });
+        return apiRecords;
+    }
+}
+exports.PdrSearch = PdrSearch;
+//# sourceMappingURL=PdrSearch.js.map

package/dist/search/ProviderSearch.d.ts

@@ -0,0 +1,32 @@
+import { Knex } from 'knex';
+import { ApiProvider } from '@cumulus/types/api/providers';
+import { BaseSearch } from './BaseSearch';
+import { DbQueryParameters, QueryEvent } from '../types/search';
+import { PostgresProviderRecord } from '../types/provider';
+/**
+ * Class to build and execute db search query for collections
+ */
+export declare class ProviderSearch extends BaseSearch {
+    constructor(event: QueryEvent);
+    /**
+     * 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 Provider records returned from query
+     * @returns translated api records
+     */
+    protected translatePostgresRecordsToApiRecords(pgRecords: PostgresProviderRecord[]): Promise<Partial<ApiProvider>[]>;
+}
+//# sourceMappingURL=ProviderSearch.d.ts.map

package/dist/search/ProviderSearch.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProviderSearch = void 0;
+const pick_1 = __importDefault(require("lodash/pick"));
+const logger_1 = __importDefault(require("@cumulus/logger"));
+const BaseSearch_1 = require("./BaseSearch");
+const providers_1 = require("../translate/providers");
+const log = new logger_1.default({ sender: '@cumulus/db/ProviderSearch' });
+/**
+ * Class to build and execute db search query for collections
+ */
+class ProviderSearch extends BaseSearch_1.BaseSearch {
+    constructor(event) {
+        const queryStringParameters = event.queryStringParameters || {};
+        super({ queryStringParameters }, 'provider');
+    }
+    /**
+     * 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}%`));
+        }
+    }
+    /**
+     * Translate postgres records to api records
+     *
+     * @param pgRecords - postgres Provider records returned from query
+     * @returns translated api records
+     */
+    async translatePostgresRecordsToApiRecords(pgRecords) {
+        log.debug(`translatePostgresRecordsToApiRecords number of records ${pgRecords.length} `);
+        const apiRecords = pgRecords.map((record) => {
+            const apiRecord = (0, providers_1.translatePostgresProviderToApiProvider)(record);
+            const apiRecordFinal = this.dbQueryParameters.fields
+                ? (0, pick_1.default)(apiRecord, this.dbQueryParameters.fields)
+                : apiRecord;
+            return apiRecordFinal;
+        });
+        return apiRecords;
+    }
+}
+exports.ProviderSearch = ProviderSearch;
+//# sourceMappingURL=ProviderSearch.js.map

package/dist/search/ReconciliationReportSearch.d.ts

@@ -0,0 +1,42 @@
+import { Knex } from 'knex';
+import { ApiReconciliationReportRecord } from '@cumulus/types/api/reconciliation_reports';
+import { BaseSearch } from './BaseSearch';
+import { DbQueryParameters, QueryEvent } from '../types/search';
+import { PostgresReconciliationReportRecord } from '../types/reconciliation_report';
+/**
+ * Class to build and execute db search query for granules
+ */
+export declare class ReconciliationReportSearch 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: PostgresReconciliationReportRecord[]): Partial<ApiReconciliationReportRecord>[];
+}
+//# sourceMappingURL=ReconciliationReportSearch.d.ts.map

package/dist/search/ReconciliationReportSearch.js

@@ -0,0 +1,72 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReconciliationReportSearch = void 0;
+const logger_1 = __importDefault(require("@cumulus/logger"));
+const pick_1 = __importDefault(require("lodash/pick"));
+const BaseSearch_1 = require("./BaseSearch");
+const reconciliation_reports_1 = require("../translate/reconciliation_reports");
+const tables_1 = require("../tables");
+const log = new logger_1.default({ sender: '@cumulus/db/ReconciliationReportSearch' });
+/**
+ * Class to build and execute db search query for granules
+ */
+class ReconciliationReportSearch extends BaseSearch_1.BaseSearch {
+    constructor(event) {
+        super(event, 'reconciliationReport');
+    }
+    /**
+     * Build basic query
+     *
+     * @param knex - DB client
+     * @returns queries for getting count and search result
+     */
+    buildBasicQuery(knex) {
+        const { reconciliationReports: reconciliationReportsTable, } = tables_1.TableNames;
+        const countQuery = knex(this.tableName)
+            .count('*');
+        const searchQuery = knex(this.tableName)
+            .select(`${this.tableName}.*`)
+            .select({
+            reconciliationReportsName: `${reconciliationReportsTable}.name`,
+        });
+        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}%`));
+        }
+    }
+    /**
+     * 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((pgRecord) => {
+            const apiRecord = (0, reconciliation_reports_1.translatePostgresReconReportToApiReconReport)(pgRecord);
+            return fields ? (0, pick_1.default)(apiRecord, fields) : apiRecord;
+        });
+        return apiRecords;
+    }
+}
+exports.ReconciliationReportSearch = ReconciliationReportSearch;
+//# sourceMappingURL=ReconciliationReportSearch.js.map

package/dist/search/RuleSearch.d.ts

@@ -0,0 +1,49 @@
+import { Knex } from 'knex';
+import { RuleRecord } from '@cumulus/types/api/rules';
+import { BaseSearch } from './BaseSearch';
+import { DbQueryParameters, QueryEvent } from '../types/search';
+import { PostgresRuleRecord } from '../types/rule';
+interface RuleRecordWithExternals extends PostgresRuleRecord {
+    collectionName: string;
+    collectionVersion: string;
+    providerName?: string;
+}
+/**
+ * Class to build and execute db search query for rules
+ */
+export declare class RuleSearch 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 Rule records returned from query
+    * @param knex - knex for the translation method
+    * @returns translated api records
+    */
+    protected translatePostgresRecordsToApiRecords(pgRecords: RuleRecordWithExternals[]): Promise<Partial<RuleRecord>[]>;
+}
+export {};
+//# sourceMappingURL=RuleSearch.d.ts.map

package/dist/search/RuleSearch.js

@@ -0,0 +1,95 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuleSearch = void 0;
+const pick_1 = __importDefault(require("lodash/pick"));
+const logger_1 = __importDefault(require("@cumulus/logger"));
+const BaseSearch_1 = require("./BaseSearch");
+const rules_1 = require("../translate/rules");
+const tables_1 = require("../tables");
+const log = new logger_1.default({ sender: '@cumulus/db/RuleSearch' });
+/**
+ * Class to build and execute db search query for rules
+ */
+class RuleSearch extends BaseSearch_1.BaseSearch {
+    constructor(event) {
+        super(event, 'rule');
+    }
+    /**
+    * Build basic query
+    *
+    * @param knex - DB client
+    * @returns queries for getting count and search result
+    */
+    buildBasicQuery(knex) {
+        const { collections: collectionsTable, providers: providersTable, } = tables_1.TableNames;
+        const countQuery = knex(this.tableName)
+            .count(`${this.tableName}.cumulus_id`);
+        const searchQuery = knex(this.tableName)
+            .select(`${this.tableName}.*`)
+            .select({
+            collectionName: `${collectionsTable}.name`,
+            collectionVersion: `${collectionsTable}.version`,
+            providerName: `${providersTable}.name`,
+        });
+        if (this.searchCollection()) {
+            searchQuery.innerJoin(collectionsTable, `${this.tableName}.collection_cumulus_id`, `${collectionsTable}.cumulus_id`);
+            countQuery.innerJoin(collectionsTable, `${this.tableName}.collection_cumulus_id`, `${collectionsTable}.cumulus_id`);
+        }
+        else {
+            searchQuery.leftJoin(collectionsTable, `${this.tableName}.collection_cumulus_id`, `${collectionsTable}.cumulus_id`);
+        }
+        if (this.searchProvider()) {
+            searchQuery.innerJoin(providersTable, `${this.tableName}.provider_cumulus_id`, `${providersTable}.cumulus_id`);
+            countQuery.innerJoin(providersTable, `${this.tableName}.provider_cumulus_id`, `${providersTable}.cumulus_id`);
+        }
+        else {
+            searchQuery.leftJoin(providersTable, `${this.tableName}.provider_cumulus_id`, `${providersTable}.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}.name`, `%${infix}%`));
+        }
+        if (prefix) {
+            [countQuery, searchQuery].forEach((query) => query.whereLike(`${this.tableName}.name`, `${prefix}%`));
+        }
+    }
+    /**
+    * Translate postgres records to api records
+    *
+    * @param pgRecords - postgres Rule records returned from query
+    * @param knex - knex for the translation method
+    * @returns translated api records
+    */
+    async translatePostgresRecordsToApiRecords(pgRecords) {
+        log.debug(`translatePostgresRecordsToApiRecords number of records ${pgRecords.length} `);
+        const apiRecords = pgRecords.map(async (record) => {
+            const providerPgRecord = record.providerName ? { name: record.providerName } : undefined;
+            const collectionPgRecord = record.collectionName ? {
+                name: record.collectionName,
+                version: record.collectionVersion,
+            } : undefined;
+            const apiRecord = await (0, rules_1.translatePostgresRuleToApiRuleWithoutDbQuery)(record, collectionPgRecord, providerPgRecord);
+            return this.dbQueryParameters.fields
+                ? (0, pick_1.default)(apiRecord, this.dbQueryParameters.fields)
+                : apiRecord;
+        });
+        return await Promise.all(apiRecords);
+    }
+}
+exports.RuleSearch = RuleSearch;
+//# sourceMappingURL=RuleSearch.js.map

package/dist/search/StatsSearch.d.ts

@@ -93,7 +93,6 @@ declare class StatsSearch extends BaseSearch {
      * @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;

package/dist/search/StatsSearch.js

@@ -16,6 +16,7 @@ const infixMapping = {
     providers: 'name',
     executions: 'arn',
     pdrs: 'name',
+    reconciliationReports: 'name',
 };
 /**
  * A class to query postgres for the STATS and STATS/AGGREGATE endpoints
@@ -170,7 +171,7 @@ class StatsSearch extends BaseSearch_1.BaseSearch {
             searchQuery.whereLike(`${this.tableName}.${fieldName}`, `%${infix}%`);
         }
         if (prefix) {
-            searchQuery.whereLike(`${this.tableName}.${fieldName}`, `%${prefix}%`);
+            searchQuery.whereLike(`${this.tableName}.${fieldName}`, `${prefix}%`);
         }
     }
     /**
@@ -179,7 +180,6 @@ class StatsSearch extends BaseSearch_1.BaseSearch {
      * @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;
@@ -187,7 +187,7 @@ class StatsSearch extends BaseSearch_1.BaseSearch {
         if (this.field?.includes('error.Error')) {
             searchQuery.whereRaw(`${this.tableName}.error ->> 'Error' is not null`);
         }
-        return super.buildTermQuery({
+        super.buildTermQuery({
             ...params,
             dbQueryParameters: { term: (0, omit_1.default)(term, 'error.Error') },
         });