@cumulus/db 9.2.4 → 9.4.1

package/dist/config.js

@@ -103,7 +103,7 @@ exports.getConnectionConfig = async ({ env, secretsManager = new aws_sdk_1.defau
  * @returns {Promise<Knex.Config>} a Knex configuration object
  */
 exports.getKnexConfig = async ({ env = process.env, secretsManager = new aws_sdk_1.default.SecretsManager(), } = {}) => {
-    var _a, _b, _c;
+    var _a, _b, _c, _d, _e, _f, _g;
     const knexConfig = {
         client: 'pg',
         connection: await exports.getConnectionConfig({ env, secretsManager }),
@@ -116,11 +116,16 @@ exports.getKnexConfig = async ({ env = process.env, secretsManager = new aws_sdk
             // ts-ignore as https://github.com/knex/knex/blob/master/types/index.d.ts#L1886
             // is improperly typed.
             //@ts-ignore
-            createTimeoutMillis: Number.parseInt((_c = env.createTimeoutMillis) !== null && _c !== void 0 ? _c : '60000', 10),
+            acquireTimeoutMillis: Number.parseInt((_c = env.acquireTimeoutMillis) !== null && _c !== void 0 ? _c : '90000', 10),
+            createRetryIntervalMillis: Number.parseInt((_d = env.createRetryIntervalMillis) !== null && _d !== void 0 ? _d : '30000', 10),
+            createTimeoutMillis: Number.parseInt((_e = env.createTimeoutMillis) !== null && _e !== void 0 ? _e : '20000', 10),
+            destroyTimeoutMillis: Number.parseInt((_f = env.destroyTimeoutMillis) !== null && _f !== void 0 ? _f : '5000', 10),
+            reapIntervalMillis: Number.parseInt((_g = env.reapIntervalMillis) !== null && _g !== void 0 ? _g : '1000', 10),
+            propagateCreateError: false,
         },
     };
-    knexConfig.acquireConnectionTimeout = env.knexAcquireConnectionTimeout
-        ? Number(env.knexAcquireConnectionTimeout)
+    knexConfig.acquireConnectionTimeout = env.acquireTimeoutMillis
+        ? Number(env.acquireTimeoutMillis + 1000)
         : 60000;
     if (env.migrationDir) {
         knexConfig.migrations = {

package/dist/connection.d.ts

@@ -1,9 +1,7 @@
 /// <reference types="node" />
 import AWS from 'aws-sdk';
 import Knex from 'knex';
-export declare const queryHeartbeat: ({ knex, }: {
-    knex: Knex;
-}) => Promise<void>;
+import Logger from '@cumulus/logger';
 /**
  * Given a NodeJS.ProcessEnv with configuration values, build and return
  * Knex client
@@ -36,15 +34,11 @@ export declare const queryHeartbeat: ({ knex, }: {
  *   acquireConnectionTimeout connection timeout
  * @param {string} [params.env.migrationDir] - Directory to look in for
  *   migrations
- * @param {string} params.env.dbHeartBeat - Configuration option if set to 'true'
- *                                          causes the method to test the connection
- *                                          before returning a knex object.  Will retry
- *                                          on KnexTimeOutError due possible RDS serverless
- *                                          deployment architechtures
  * @returns {Promise<Knex>} a Knex configuration object that has returned at least one query
  */
-export declare const getKnexClient: ({ env, secretsManager, }?: {
+export declare const getKnexClient: ({ env, secretsManager, knexLogger, }?: {
     env?: NodeJS.ProcessEnv | undefined;
     secretsManager?: AWS.SecretsManager | undefined;
+    knexLogger?: Logger | undefined;
 }) => Promise<Knex>;
 //# sourceMappingURL=connection.d.ts.map

package/dist/connection.js

@@ -3,26 +3,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getKnexClient = exports.queryHeartbeat = void 0;
+exports.getKnexClient = void 0;
 const aws_sdk_1 = __importDefault(require("aws-sdk"));
 const knex_1 = __importDefault(require("knex"));
-const p_retry_1 = __importDefault(require("p-retry"));
 const logger_1 = __importDefault(require("@cumulus/logger"));
 const config_1 = require("./config");
 const log = new logger_1.default({ sender: '@cumulus/db/connection' });
-exports.queryHeartbeat = async ({ knex, }) => await p_retry_1.default(async () => {
-    log.info('Sending Heartbeat Query');
-    await knex.raw('SELECT 1');
-    log.info('Heartbeat succeeded');
-}, {
-    onFailedAttempt: (error) => {
-        if (error.name !== 'KnexTimeoutError') {
-            throw error;
-        }
-        log.warn(`Failed intial attempt at RDS DB connection due to ${error.name}`);
-    },
-    retries: 1,
-});
 /**
  * Given a NodeJS.ProcessEnv with configuration values, build and return
  * Knex client
@@ -55,25 +41,19 @@ exports.queryHeartbeat = async ({ knex, }) => await p_retry_1.default(async () =
  *   acquireConnectionTimeout connection timeout
  * @param {string} [params.env.migrationDir] - Directory to look in for
  *   migrations
- * @param {string} params.env.dbHeartBeat - Configuration option if set to 'true'
- *                                          causes the method to test the connection
- *                                          before returning a knex object.  Will retry
- *                                          on KnexTimeOutError due possible RDS serverless
- *                                          deployment architechtures
  * @returns {Promise<Knex>} a Knex configuration object that has returned at least one query
  */
-exports.getKnexClient = async ({ env = process.env, secretsManager = new aws_sdk_1.default.SecretsManager(), } = {}) => {
+exports.getKnexClient = async ({ env = process.env, secretsManager = new aws_sdk_1.default.SecretsManager(), knexLogger = log, } = {}) => {
     const knexConfig = await config_1.getKnexConfig({ env, secretsManager });
     const knex = knex_1.default(knexConfig);
-    if (env.dbHeartBeat === 'true') {
-        try {
-            await exports.queryHeartbeat({ knex });
-        }
-        catch (error) {
-            knex.destroy();
-            throw error;
-        }
-    }
+    //@ts-ignore
+    // context is an internal object that isn't typed
+    // this is needed to force tarn to log per-retry failures
+    // and allow propagateCreateError to be set `false`
+    knex.context.client.pool.on('createFail', (_, error) => {
+        knexLogger.warn('knex failed on attempted connection', error);
+        throw error;
+    });
     return knex;
 };
 //# sourceMappingURL=connection.js.map

package/dist/index.d.ts

@@ -17,10 +17,11 @@ export { translateApiFiletoPostgresFile, } from './translate/file';
 export { translateApiCollectionToPostgresCollection } from './translate/collections';
 export { translateApiProviderToPostgresProvider, } from './translate/providers';
 export { translateApiRuleToPostgresRule } from './translate/rules';
-export { translateApiExecutionToPostgresExecution } from './translate/executions';
+export { translateApiExecutionToPostgresExecution, translatePostgresExecutionToApiExecution, } from './translate/executions';
 export { translateApiGranuleToPostgresGranule } from './translate/granules';
 export { translateApiPdrToPostgresPdr } from './translate/pdrs';
-export { upsertGranuleWithExecutionJoinRecord, } from './lib/granule';
+export { executionArnsFromGranuleIdsAndWorkflowNames, newestExecutionArnFromGranuleIdWorkflowName, getWorkflowNameIntersectFromGranuleIds, } from './lib/execution';
+export { getApiGranuleCumulusIds, getApiGranuleExecutionCumulusIds, upsertGranuleWithExecutionJoinRecord, } from './lib/granule';
 export { AsyncOperationPgModel } from './models/async_operation';
 export { BasePgModel } from './models/base';
 export { CollectionPgModel } from './models/collection';

package/dist/index.js

@@ -36,11 +36,18 @@ var rules_1 = require("./translate/rules");
 Object.defineProperty(exports, "translateApiRuleToPostgresRule", { enumerable: true, get: function () { return rules_1.translateApiRuleToPostgresRule; } });
 var executions_1 = require("./translate/executions");
 Object.defineProperty(exports, "translateApiExecutionToPostgresExecution", { enumerable: true, get: function () { return executions_1.translateApiExecutionToPostgresExecution; } });
+Object.defineProperty(exports, "translatePostgresExecutionToApiExecution", { enumerable: true, get: function () { return executions_1.translatePostgresExecutionToApiExecution; } });
 var granules_1 = require("./translate/granules");
 Object.defineProperty(exports, "translateApiGranuleToPostgresGranule", { enumerable: true, get: function () { return granules_1.translateApiGranuleToPostgresGranule; } });
 var pdrs_1 = require("./translate/pdrs");
 Object.defineProperty(exports, "translateApiPdrToPostgresPdr", { enumerable: true, get: function () { return pdrs_1.translateApiPdrToPostgresPdr; } });
+var execution_1 = require("./lib/execution");
+Object.defineProperty(exports, "executionArnsFromGranuleIdsAndWorkflowNames", { enumerable: true, get: function () { return execution_1.executionArnsFromGranuleIdsAndWorkflowNames; } });
+Object.defineProperty(exports, "newestExecutionArnFromGranuleIdWorkflowName", { enumerable: true, get: function () { return execution_1.newestExecutionArnFromGranuleIdWorkflowName; } });
+Object.defineProperty(exports, "getWorkflowNameIntersectFromGranuleIds", { enumerable: true, get: function () { return execution_1.getWorkflowNameIntersectFromGranuleIds; } });
 var granule_1 = require("./lib/granule");
+Object.defineProperty(exports, "getApiGranuleCumulusIds", { enumerable: true, get: function () { return granule_1.getApiGranuleCumulusIds; } });
+Object.defineProperty(exports, "getApiGranuleExecutionCumulusIds", { enumerable: true, get: function () { return granule_1.getApiGranuleExecutionCumulusIds; } });
 Object.defineProperty(exports, "upsertGranuleWithExecutionJoinRecord", { enumerable: true, get: function () { return granule_1.upsertGranuleWithExecutionJoinRecord; } });
 var async_operation_1 = require("./models/async_operation");
 Object.defineProperty(exports, "AsyncOperationPgModel", { enumerable: true, get: function () { return async_operation_1.AsyncOperationPgModel; } });
@@ -48,8 +55,8 @@ var base_1 = require("./models/base");
 Object.defineProperty(exports, "BasePgModel", { enumerable: true, get: function () { return base_1.BasePgModel; } });
 var collection_1 = require("./models/collection");
 Object.defineProperty(exports, "CollectionPgModel", { enumerable: true, get: function () { return collection_1.CollectionPgModel; } });
-var execution_1 = require("./models/execution");
-Object.defineProperty(exports, "ExecutionPgModel", { enumerable: true, get: function () { return execution_1.ExecutionPgModel; } });
+var execution_2 = require("./models/execution");
+Object.defineProperty(exports, "ExecutionPgModel", { enumerable: true, get: function () { return execution_2.ExecutionPgModel; } });
 var file_2 = require("./models/file");
 Object.defineProperty(exports, "FilePgModel", { enumerable: true, get: function () { return file_2.FilePgModel; } });
 var granule_2 = require("./models/granule");

package/dist/lib/execution.d.ts

@@ -0,0 +1,36 @@
+import Knex from 'knex';
+export interface arnRecord {
+    arn: string;
+}
+/**
+ * Returns a list of executionArns sorted by most recent first, for an input
+ * list of granuleIds and workflowNames.
+ *
+ * @param {Knex} knex - DB Client
+ * @param {string[]} granuleIds - Array of granuleIds
+ * @param {string[]} workflowNames - Array of workflow names
+ * @returns {Promise<arnRecord[]>} - Array of arn objects with the most recent first.
+ */
+export declare const executionArnsFromGranuleIdsAndWorkflowNames: (knex: Knex, granuleIds: string[], workflowNames: string[]) => Promise<arnRecord[]>;
+/**
+ * convenience function to return a single executionArn string for a intput
+ *  granuleId and workflowName.
+ *
+ * @param {string} granuleId -  granuleIds
+ * @param {string} workflowName - workflow name
+ * @returns {Promise<string>} - most recent exectutionArn for input parameters.
+ * @throws {RecordNotFound}
+ */
+export declare const newestExecutionArnFromGranuleIdWorkflowName: (granuleId: string, workflowName: string, testKnex: Knex | undefined) => Promise<string>;
+/**
+ * Returns the intersect of workflow names that exist for all granule ids that are passed in
+ * When a single granule is passed in, workflow names are sorted by most recent first
+ *
+ * @param {Knex | Knex.Transaction} knexOrTransaction - DB Client or transaction
+ * @param {Array<string>} granuleCumulusIds - Array of granule cumulus ids to query
+ * @returns {Promise<string[]>} - Array consisting of workflow names common to all granules.
+ * Sorted by most recent when array includes a single granule
+ * @throws {RecordNotFound}
+ */
+export declare const getWorkflowNameIntersectFromGranuleIds: (knexOrTransaction: Knex | Knex.Transaction, granuleCumulusIds: Array<number> | number) => Promise<Array<string>>;
+//# sourceMappingURL=execution.d.ts.map

package/dist/lib/execution.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWorkflowNameIntersectFromGranuleIds = exports.newestExecutionArnFromGranuleIdWorkflowName = exports.executionArnsFromGranuleIdsAndWorkflowNames = void 0;
+const errors_1 = require("@cumulus/errors");
+const tables_1 = require("../tables");
+const Logger = require('@cumulus/logger');
+const { getKnexClient } = require('../connection');
+const log = new Logger({ sender: '@cumulus/db/lib/execution' });
+/**
+ * Returns a list of executionArns sorted by most recent first, for an input
+ * list of granuleIds and workflowNames.
+ *
+ * @param {Knex} knex - DB Client
+ * @param {string[]} granuleIds - Array of granuleIds
+ * @param {string[]} workflowNames - Array of workflow names
+ * @returns {Promise<arnRecord[]>} - Array of arn objects with the most recent first.
+ */
+exports.executionArnsFromGranuleIdsAndWorkflowNames = (knex, granuleIds, workflowNames) => knex
+    .select(`${tables_1.tableNames.executions}.arn`)
+    .from(tables_1.tableNames.executions)
+    .join(tables_1.tableNames.granulesExecutions, `${tables_1.tableNames.executions}.cumulus_id`, `${tables_1.tableNames.granulesExecutions}.execution_cumulus_id`)
+    .join(tables_1.tableNames.granules, `${tables_1.tableNames.granules}.cumulus_id`, `${tables_1.tableNames.granulesExecutions}.granule_cumulus_id`)
+    .whereIn(`${tables_1.tableNames.granules}.granule_id`, granuleIds)
+    .whereIn(`${tables_1.tableNames.executions}.workflow_name`, workflowNames)
+    .orderBy(`${tables_1.tableNames.executions}.timestamp`, 'desc');
+/**
+ * convenience function to return a single executionArn string for a intput
+ *  granuleId and workflowName.
+ *
+ * @param {string} granuleId -  granuleIds
+ * @param {string} workflowName - workflow name
+ * @returns {Promise<string>} - most recent exectutionArn for input parameters.
+ * @throws {RecordNotFound}
+ */
+exports.newestExecutionArnFromGranuleIdWorkflowName = async (granuleId, workflowName, testKnex) => {
+    try {
+        const knex = testKnex !== null && testKnex !== void 0 ? testKnex : await getKnexClient({ env: process.env });
+        const executions = await exports.executionArnsFromGranuleIdsAndWorkflowNames(knex, [granuleId], [workflowName]);
+        if (executions.length === 0) {
+            throw new errors_1.RecordDoesNotExist(`No executionArns found for granuleId:${granuleId} running workflow:${workflowName}`);
+        }
+        return executions[0].arn;
+    }
+    catch (error) {
+        log.error(error);
+        throw error;
+    }
+};
+/**
+ * Returns the intersect of workflow names that exist for all granule ids that are passed in
+ * When a single granule is passed in, workflow names are sorted by most recent first
+ *
+ * @param {Knex | Knex.Transaction} knexOrTransaction - DB Client or transaction
+ * @param {Array<string>} granuleCumulusIds - Array of granule cumulus ids to query
+ * @returns {Promise<string[]>} - Array consisting of workflow names common to all granules.
+ * Sorted by most recent when array includes a single granule
+ * @throws {RecordNotFound}
+ */
+exports.getWorkflowNameIntersectFromGranuleIds = async (knexOrTransaction, granuleCumulusIds) => {
+    const granuleCumulusIdsArray = [granuleCumulusIds].flat();
+    const numberOfGranules = granuleCumulusIdsArray.length;
+    const { executions: executionsTable, granulesExecutions: granulesExecutionsTable } = tables_1.tableNames;
+    const aggregatedWorkflowCounts = await knexOrTransaction(executionsTable)
+        .select('workflow_name')
+        .countDistinct('granule_cumulus_id')
+        .innerJoin(granulesExecutionsTable, `${executionsTable}.cumulus_id`, `${granulesExecutionsTable}.execution_cumulus_id`)
+        .whereIn('granule_cumulus_id', granuleCumulusIdsArray)
+        .groupBy('workflow_name')
+        .havingRaw('count(distinct granule_cumulus_id) = ?', [numberOfGranules])
+        .modify((queryBuilder) => {
+        if (numberOfGranules === 1) {
+            queryBuilder.groupBy('timestamp')
+                .orderBy('timestamp', 'desc');
+        }
+    });
+    return aggregatedWorkflowCounts
+        .map((workflowCounts) => workflowCounts.workflow_name);
+};
+//# sourceMappingURL=execution.js.map

package/dist/lib/granule.d.ts

@@ -1,5 +1,6 @@
 import Knex from 'knex';
 import { PostgresGranule } from '../types/granule';
+import { CollectionPgModel } from '../models/collection';
 import { GranulePgModel } from '../models/granule';
 import { GranulesExecutionsPgModel } from '../models/granules-executions';
 /**
@@ -14,4 +15,34 @@ import { GranulesExecutionsPgModel } from '../models/granules-executions';
  * @returns {Promise<number[]>}
  */
 export declare const upsertGranuleWithExecutionJoinRecord: (knexTransaction: Knex.Transaction, granule: PostgresGranule, executionCumulusId?: number | undefined, granulePgModel?: GranulePgModel, granulesExecutionsPgModel?: GranulesExecutionsPgModel) => Promise<number[]>;
+/**
+ * Get cumulus IDs for list of granules
+ *
+ * @param {Knex | Knex.Transaction} knexOrTransaction -
+ *  DB client or transaction
+ * @param {Array<Object>} granules - array of granules with collectionId and granuleId
+ * @param {Object} [collectionPgModel] - Collection PG model class instance
+ * @param {Object} [granulePgModel] - Granule PG model class instance
+ * @returns {Promise<number[]>}
+ */
+export declare const getApiGranuleCumulusIds: (knexOrTransaction: Knex | Knex.Transaction, granules: Array<{
+    collectionId: string;
+    granuleId: string;
+}>, collectionPgModel?: CollectionPgModel, granulePgModel?: GranulePgModel) => Promise<number[]>;
+/**
+ * Get cumulus IDs for all executions associated to a set of granules
+ *
+ * @param {Knex | Knex.Transaction} knexOrTransaction -
+ *  DB client or transaction
+ * @param {Array<Object>} granules - array of granules with collectionId and granuleId
+ * @param {Object} [collectionPgModel] - Collection PG model class instance
+ * @param {Object} [granulePgModel] - Granule PG model class instance
+ * @param {Object} [granulesExecutionsPgModel]
+ *   Granules/executions PG model class instance
+ * @returns {Promise<number[]>}
+ */
+export declare const getApiGranuleExecutionCumulusIds: (knexOrTransaction: Knex | Knex.Transaction, granules: Array<{
+    collectionId: string;
+    granuleId: string;
+}>, collectionPgModel?: CollectionPgModel, granulePgModel?: GranulePgModel, granulesExecutionsPgModel?: GranulesExecutionsPgModel) => Promise<Array<number>>;
 //# sourceMappingURL=granule.d.ts.map

package/dist/lib/granule.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.upsertGranuleWithExecutionJoinRecord = void 0;
+exports.getApiGranuleExecutionCumulusIds = exports.getApiGranuleCumulusIds = exports.upsertGranuleWithExecutionJoinRecord = void 0;
+const collection_1 = require("../models/collection");
 const granule_1 = require("../models/granule");
 const granules_executions_1 = require("../models/granules-executions");
+const { deconstructCollectionId } = require('@cumulus/message/Collections');
 /**
  * Upsert a granule and a record in the granules/executions join table.
  *
@@ -31,4 +33,49 @@ exports.upsertGranuleWithExecutionJoinRecord = async (knexTransaction, granule,
     }
     return [granuleCumulusId];
 };
+/**
+ * Get cumulus IDs for list of granules
+ *
+ * @param {Knex | Knex.Transaction} knexOrTransaction -
+ *  DB client or transaction
+ * @param {Array<Object>} granules - array of granules with collectionId and granuleId
+ * @param {Object} [collectionPgModel] - Collection PG model class instance
+ * @param {Object} [granulePgModel] - Granule PG model class instance
+ * @returns {Promise<number[]>}
+ */
+exports.getApiGranuleCumulusIds = async (knexOrTransaction, granules, collectionPgModel = new collection_1.CollectionPgModel(), granulePgModel = new granule_1.GranulePgModel()) => {
+    const collectionMap = {};
+    const granuleCumulusIds = await Promise.all(granules.map(async (granule) => {
+        const { collectionId } = granule;
+        let collectionCumulusId = collectionMap[collectionId];
+        if (!collectionCumulusId) {
+            const { name, version } = deconstructCollectionId(collectionId);
+            collectionCumulusId = await collectionPgModel.getRecordCumulusId(knexOrTransaction, { name, version });
+            collectionMap[collectionId] = collectionCumulusId;
+        }
+        return await granulePgModel.getRecordCumulusId(knexOrTransaction, {
+            granule_id: granule.granuleId,
+            collection_cumulus_id: collectionCumulusId,
+        });
+    }));
+    return [...new Set(granuleCumulusIds)];
+};
+/**
+ * Get cumulus IDs for all executions associated to a set of granules
+ *
+ * @param {Knex | Knex.Transaction} knexOrTransaction -
+ *  DB client or transaction
+ * @param {Array<Object>} granules - array of granules with collectionId and granuleId
+ * @param {Object} [collectionPgModel] - Collection PG model class instance
+ * @param {Object} [granulePgModel] - Granule PG model class instance
+ * @param {Object} [granulesExecutionsPgModel]
+ *   Granules/executions PG model class instance
+ * @returns {Promise<number[]>}
+ */
+exports.getApiGranuleExecutionCumulusIds = async (knexOrTransaction, granules, collectionPgModel = new collection_1.CollectionPgModel(), granulePgModel = new granule_1.GranulePgModel(), granulesExecutionsPgModel = new granules_executions_1.GranulesExecutionsPgModel()) => {
+    const granuleCumulusIds = await exports.getApiGranuleCumulusIds(knexOrTransaction, granules, collectionPgModel, granulePgModel);
+    const executionCumulusIds = await granulesExecutionsPgModel
+        .searchByGranuleCumulusIds(knexOrTransaction, granuleCumulusIds);
+    return executionCumulusIds;
+};
 //# sourceMappingURL=granule.js.map

package/dist/lib/sort.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Returns an array of sort fields and their order for use with PostGres
+ * modified from @cumulus/es-client/queries
+ *
+ * @param {Object} params - sort params
+ */
+export declare const getSortFields: (params: {
+    sort_by?: string;
+    order?: string;
+    sort_key?: Array<string>;
+}) => {
+    [x: string]: {
+        order: string;
+    };
+}[];
+//# sourceMappingURL=sort.d.ts.map

package/dist/lib/sort.js

@@ -0,0 +1,28 @@
+"use strict";
+/**
+ * Returns an array of sort fields and their order for use with PostGres
+ * modified from @cumulus/es-client/queries
+ *
+ * @param {Object} params - sort params
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSortFields = void 0;
+exports.getSortFields = (params) => {
+    let sort;
+    const { sort_by: sortBy, order, sort_key: sortKey } = params;
+    if (sortBy && order) {
+        const sortField = sortBy;
+        sort = [{ [sortField]: { order: order } }];
+    }
+    else if (sortKey && Array.isArray(sortKey)) {
+        sort = sortKey.map((key) => {
+            const sortField = key.replace(/^[+-]/, '');
+            return { [sortField]: { order: key.startsWith('-') ? 'desc' : 'asc' } };
+        });
+    }
+    else {
+        sort = [{ timestamp: { order: 'desc' } }];
+    }
+    return sort;
+};
+//# sourceMappingURL=sort.js.map

package/dist/models/base.d.ts

@@ -36,6 +36,16 @@ declare class BasePgModel<ItemType, RecordType extends {
      * @returns {Promise<number>} The cumulus_id of the returned record
      */
     getRecordCumulusId(knexOrTransaction: Knex | Knex.Transaction, whereClause: Partial<RecordType>): Promise<number>;
+    /**
+     * Get cumulus_id column value for multiple records in Postgres
+     *
+     * @param {Knex | Knex.Transaction} knexOrTransaction -
+     *  DB client or transaction
+     * @param {Array<keyof RecordType>} columnNames - column names for whereIn query
+     * @param {Array<string>} values - record values for whereIn query
+     * @returns {Promise<Array<number>>} An array of cumulus_ids for the returned records
+     */
+    getRecordsCumulusIds(knexOrTransaction: Knex | Knex.Transaction, columnNames: Array<keyof RecordType>, values: Array<any>): Promise<Array<number>>;
     /**
      * Checks if an item is present in Postgres
      *

package/dist/models/base.js

@@ -67,6 +67,21 @@ class BasePgModel {
         }
         return record.cumulus_id;
     }
+    /**
+     * Get cumulus_id column value for multiple records in Postgres
+     *
+     * @param {Knex | Knex.Transaction} knexOrTransaction -
+     *  DB client or transaction
+     * @param {Array<keyof RecordType>} columnNames - column names for whereIn query
+     * @param {Array<string>} values - record values for whereIn query
+     * @returns {Promise<Array<number>>} An array of cumulus_ids for the returned records
+     */
+    async getRecordsCumulusIds(knexOrTransaction, columnNames, values) {
+        const records = await knexOrTransaction(this.tableName)
+            .select('cumulus_id')
+            .whereIn(columnNames, values);
+        return records.map((record) => record.cumulus_id);
+    }
     /**
      * Checks if an item is present in Postgres
      *

package/dist/models/collection.d.ts

@@ -6,7 +6,7 @@ declare class CollectionPgModel extends BasePgModel<PostgresCollection, Postgres
     upsert(knexOrTransaction: Knex | Knex.Transaction, collection: PostgresCollection): Knex.QueryBuilder<any, {
         _base: any;
         _hasSelection: true;
-        _keys: "name" | "version" | "cumulus_id";
+        _keys: "name" | "cumulus_id" | "version";
         _aliases: {};
         _single: true;
         _intersectProps: {};

package/dist/models/execution.d.ts

@@ -4,6 +4,22 @@ import { PostgresExecution, PostgresExecutionRecord } from '../types/execution';
 declare class ExecutionPgModel extends BasePgModel<PostgresExecution, PostgresExecutionRecord> {
     constructor();
     upsert(knexOrTrx: Knex | Knex.Transaction, execution: PostgresExecution): Promise<any[]>;
+    /**
+     * Get executions from the execution cumulus_id
+     *
+     * @param {Knex | Knex.Transaction} knexOrTrx -
+     *  DB client or transaction
+     * @param {Array<number>} executionCumulusIds -
+     * single execution cumulus_id or array of exeuction cumulus_ids
+     * @param {Object} [params] - Optional object with addition params for query
+     * @param {number} [params.limit] - number of records to be returned
+     * @param {number} [params.offset] - record offset
+     * @returns {Promise<Array<number>>} An array of exeuctions
+     */
+    searchByCumulusIds(knexOrTrx: Knex | Knex.Transaction, executionCumulusIds: Array<number> | number, params: {
+        limit: number;
+        offset: number;
+    }): Promise<Array<number>>;
 }
 export { ExecutionPgModel };
 //# sourceMappingURL=execution.d.ts.map

package/dist/models/execution.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExecutionPgModel = void 0;
 const base_1 = require("./base");
 const tables_1 = require("../tables");
+const sort_1 = require("../lib/sort");
 class ExecutionPgModel extends base_1.BasePgModel {
     constructor() {
         super({
@@ -28,6 +29,39 @@ class ExecutionPgModel extends base_1.BasePgModel {
             .merge()
             .returning('cumulus_id');
     }
+    /**
+     * Get executions from the execution cumulus_id
+     *
+     * @param {Knex | Knex.Transaction} knexOrTrx -
+     *  DB client or transaction
+     * @param {Array<number>} executionCumulusIds -
+     * single execution cumulus_id or array of exeuction cumulus_ids
+     * @param {Object} [params] - Optional object with addition params for query
+     * @param {number} [params.limit] - number of records to be returned
+     * @param {number} [params.offset] - record offset
+     * @returns {Promise<Array<number>>} An array of exeuctions
+     */
+    async searchByCumulusIds(knexOrTrx, executionCumulusIds, params) {
+        const { limit, offset, ...sortQueries } = params || {};
+        const sortFields = sort_1.getSortFields(sortQueries);
+        const executionCumulusIdsArray = [executionCumulusIds].flat();
+        const executions = await knexOrTrx(this.tableName)
+            .whereIn('cumulus_id', executionCumulusIdsArray)
+            .modify((queryBuilder) => {
+            if (limit)
+                queryBuilder.limit(limit);
+            if (offset)
+                queryBuilder.offset(offset);
+            if (sortFields.length >= 1) {
+                sortFields.forEach((sortObject) => {
+                    const sortField = Object.keys(sortObject)[0];
+                    const { order } = sortObject[sortField];
+                    queryBuilder.orderBy(sortField, order);
+                });
+            }
+        });
+        return executions;
+    }
 }
 exports.ExecutionPgModel = ExecutionPgModel;
 //# sourceMappingURL=execution.js.map

package/dist/models/granules-executions.d.ts

@@ -7,6 +7,16 @@ export default class GranulesExecutionsPgModel {
     create(knexTransaction: Knex.Transaction, item: PostgresGranuleExecution): Promise<number[]>;
     exists(knexTransaction: Knex.Transaction, item: PostgresGranuleExecution): Promise<boolean>;
     upsert(knexTransaction: Knex.Transaction, item: PostgresGranuleExecution): Promise<any[]>;
+    /**
+     * Get execution_cumulus_id column values from the granule_cumulus_id
+     *
+     * @param {Knex | Knex.Transaction} knexOrTransaction -
+     *  DB client or transaction
+     * @param {number | Array<number>} granuleCumulusIds -
+     * single granule_cumulus_id or array of granule_cumulus_ids
+     * @returns {Promise<Array<number>>} An array of execution_cumulus_ids
+     */
+    searchByGranuleCumulusIds(knexOrTransaction: Knex | Knex.Transaction, granuleCumulusIds: Array<number> | number): Promise<Array<number>>;
     search(knexTransaction: Knex | Knex.Transaction, query: Partial<PostgresGranuleExecution>): Knex.QueryBuilder<PostgresGranuleExecution, {
         _base: PostgresGranuleExecution;
         _hasSelection: false;

package/dist/models/granules-executions.js

@@ -21,6 +21,23 @@ class GranulesExecutionsPgModel {
             .onConflict(['granule_cumulus_id', 'execution_cumulus_id'])
             .merge();
     }
+    /**
+     * Get execution_cumulus_id column values from the granule_cumulus_id
+     *
+     * @param {Knex | Knex.Transaction} knexOrTransaction -
+     *  DB client or transaction
+     * @param {number | Array<number>} granuleCumulusIds -
+     * single granule_cumulus_id or array of granule_cumulus_ids
+     * @returns {Promise<Array<number>>} An array of execution_cumulus_ids
+     */
+    async searchByGranuleCumulusIds(knexOrTransaction, granuleCumulusIds) {
+        const granuleCumulusIdsArray = [granuleCumulusIds].flat();
+        const granuleExecutions = await knexOrTransaction(this.tableName)
+            .select('execution_cumulus_id')
+            .whereIn('granule_cumulus_id', granuleCumulusIdsArray)
+            .groupBy('execution_cumulus_id');
+        return granuleExecutions.map((granuleExecution) => granuleExecution.execution_cumulus_id);
+    }
     search(knexTransaction, query) {
         return knexTransaction(this.tableName)
             .where(query);

package/dist/provider.js

@@ -26,6 +26,7 @@ exports.nullifyUndefinedProviderValues = (data) => {
         'private_key',
         'cm_key_id',
         'certificate_uri',
+        'allowed_redirects',
     ];
     optionalValues.forEach((value) => {
         if (returnData[value] === undefined) {

package/dist/translate/executions.d.ts

@@ -1,9 +1,10 @@
 import Knex from 'knex';
 import { ExecutionRecord } from '@cumulus/types/api/executions';
-import { PostgresExecution } from '../types/execution';
+import { PostgresExecution, PostgresExecutionRecord } from '../types/execution';
 import { ExecutionPgModel } from '../models/execution';
 import { CollectionPgModel } from '../models/collection';
 import { AsyncOperationPgModel } from '../models/async_operation';
+export declare const translatePostgresExecutionToApiExecution: (executionRecord: PostgresExecutionRecord, knex: Knex, collectionPgModel?: CollectionPgModel, asyncOperationPgModel?: AsyncOperationPgModel, executionPgModel?: ExecutionPgModel) => Promise<ExecutionRecord>;
 /**
  * Translate execution record from Dynamo to RDS.
  *

package/dist/translate/executions.js

@@ -3,12 +3,62 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.translateApiExecutionToPostgresExecution = void 0;
+exports.translateApiExecutionToPostgresExecution = exports.translatePostgresExecutionToApiExecution = void 0;
 const errors_1 = require("@cumulus/errors");
 const logger_1 = __importDefault(require("@cumulus/logger"));
+const util_1 = require("@cumulus/common/util");
+const Collections_1 = require("@cumulus/message/Collections");
 const execution_1 = require("../models/execution");
 const collection_1 = require("../models/collection");
 const async_operation_1 = require("../models/async_operation");
+exports.translatePostgresExecutionToApiExecution = async (executionRecord, knex, collectionPgModel = new collection_1.CollectionPgModel(), asyncOperationPgModel = new async_operation_1.AsyncOperationPgModel(), executionPgModel = new execution_1.ExecutionPgModel()) => {
+    var _a;
+    let parentArn;
+    let collectionId;
+    let asyncOperationId;
+    if (executionRecord.collection_cumulus_id) {
+        const collection = await collectionPgModel.get(knex, {
+            cumulus_id: executionRecord.collection_cumulus_id,
+        });
+        collectionId = Collections_1.constructCollectionId(collection.name, collection.version);
+    }
+    if (executionRecord.async_operation_cumulus_id) {
+        const asyncOperation = await asyncOperationPgModel.get(knex, {
+            cumulus_id: executionRecord.async_operation_cumulus_id,
+        });
+        asyncOperationId = asyncOperation.id;
+    }
+    if (executionRecord.parent_cumulus_id) {
+        const parentExecution = await executionPgModel.get(knex, {
+            cumulus_id: executionRecord.parent_cumulus_id,
+        });
+        parentArn = parentExecution.arn;
+    }
+    const postfix = executionRecord.arn.split(':').pop();
+    if (!postfix) {
+        throw new Error(`Execution ARN record ${executionRecord.arn} has an invalid postfix and API cannot generate the required 'name' field`);
+    }
+    const translatedRecord = {
+        name: postfix,
+        status: executionRecord.status,
+        arn: executionRecord.arn,
+        duration: executionRecord.duration,
+        error: executionRecord.error,
+        tasks: executionRecord.tasks,
+        originalPayload: executionRecord.original_payload,
+        finalPayload: executionRecord.final_payload,
+        type: executionRecord.workflow_name,
+        execution: executionRecord.url,
+        cumulusVersion: executionRecord.cumulus_version,
+        asyncOperationId,
+        collectionId,
+        parentArn,
+        createdAt: executionRecord.created_at.getTime(),
+        updatedAt: executionRecord.updated_at.getTime(),
+        timestamp: (_a = executionRecord.timestamp) === null || _a === void 0 ? void 0 : _a.getTime(),
+    };
+    return util_1.removeNilProperties(translatedRecord);
+};
 /**
  * Translate execution record from Dynamo to RDS.
  *

package/dist/translate/granules.js

@@ -4,7 +4,7 @@ exports.translateApiGranuleToPostgresGranule = void 0;
 const collection_1 = require("../models/collection");
 const pdr_1 = require("../models/pdr");
 const provider_1 = require("../models/provider");
-const { deconstructCollectionId } = require('../../../api/lib/utils');
+const { deconstructCollectionId } = require('@cumulus/message/Collections');
 /**
  * Generate a Postgres granule record from a DynamoDB record.
  *

package/dist/translate/providers.js

@@ -34,6 +34,7 @@ exports.translateApiProviderToPostgresProvider = async (record, encryptMethod =
         port: record.port,
         host: record.host,
         protocol: record.protocol,
+        allowed_redirects: record.allowedRedirects,
         username,
         password,
     });

package/dist/types/provider.d.ts

@@ -18,6 +18,7 @@ export interface PostgresProvider {
     protocol: string;
     updated_at?: Date | null;
     username?: string | null;
+    allowed_redirects?: string[];
 }
 /**
  * PostgresProviderRecord
@@ -26,7 +27,7 @@ export interface PostgresProvider {
  * postgres for reading.  It differs from the PostgresProvider interface in that it types
  * the autogenerated/required fields in the Postgres database as required
  */
-export interface PostgresProviderRecord extends PostgresProvider {
+export interface PostgresProviderRecord extends Omit<PostgresProvider, 'allowed_redirects'> {
     cumulus_id: number;
     created_at: Date;
     updated_at: Date;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cumulus/db",
-  "version": "9.2.4",
+  "version": "9.4.1",
   "description": "Utilities for working with the Cumulus DB",
   "license": "Apache-2.0",
   "main": "./dist/index.js",
@@ -29,12 +29,12 @@
     "node": ">=12.18.0"
   },
   "dependencies": {
-    "@cumulus/aws-client": "9.2.4",
-    "@cumulus/common": "9.2.4",
-    "@cumulus/errors": "9.2.4",
-    "@cumulus/logger": "9.2.4",
-    "@cumulus/message": "9.2.4",
-    "@cumulus/types": "9.2.4",
+    "@cumulus/aws-client": "9.4.1",
+    "@cumulus/common": "9.4.1",
+    "@cumulus/errors": "9.4.1",
+    "@cumulus/logger": "9.4.1",
+    "@cumulus/message": "9.4.1",
+    "@cumulus/types": "9.4.1",
     "is-valid-hostname": "0.0.1",
     "knex": "0.21.13",
     "lodash": "^4.17.20",
@@ -43,8 +43,7 @@
     "uuid": "8.3.1"
   },
   "devDependencies": {
-    "@cumulus/message": "9.2.4",
     "@types/uuid": "^8.0.0"
   },
-  "gitHead": "5e5890eaefaecdcb54c382dbb2300c794378c593"
+  "gitHead": "fce4415918c43a6a14d46ac7d9572f5a97a98a45"
 }