@cumulus/db 10.1.2 → 11.0.0

package/dist/models/granule.js

@@ -4,7 +4,7 @@ exports.GranulePgModel = void 0;
 const errors_1 = require("@cumulus/errors");
 const tables_1 = require("../tables");
 const base_1 = require("./base");
-const granules_executions_1 = require("./granules-executions");
+const execution_1 = require("./execution");
 const timestamp_1 = require("../lib/timestamp");
 const sort_1 = require("../lib/sort");
 function isRecordSelect(param) {
@@ -16,6 +16,9 @@ class GranulePgModel extends base_1.BasePgModel {
             tableName: tables_1.TableNames.granules,
         });
     }
+    create(knexOrTransaction, item) {
+        return super.create(knexOrTransaction, item, '*');
+    }
     /**
      * Deletes the item from Postgres
      *
@@ -24,9 +27,10 @@ class GranulePgModel extends base_1.BasePgModel {
      * @returns {Promise<number>} The number of rows deleted
      */
     async delete(knexOrTransaction, params) {
-        return await knexOrTransaction(this.tableName)
-            .where(params)
-            .del();
+        return await knexOrTransaction(this.tableName).where(params).del();
+    }
+    async deleteExcluding() {
+        throw new Error('deleteExcluding not implemented on granule class');
     }
     /**
      * Checks if a granule is present in PostgreSQL
@@ -64,7 +68,16 @@ class GranulePgModel extends base_1.BasePgModel {
         }
         return super.get(knexOrTransaction, params);
     }
-    async upsert(knexOrTrx, granule, executionCumulusId, granulesExecutionsPgModel = new granules_executions_1.GranulesExecutionsPgModel()) {
+    _buildExclusionClause(executionPgModel, executionCumulusId, knexOrTrx, status) {
+        const queryBuilder = executionPgModel.queryBuilderSearch(knexOrTrx, {
+            cumulus_id: executionCumulusId,
+        });
+        if (status === 'running') {
+            queryBuilder.whereIn('status', execution_1.ExecutionPgModel.nonActiveStatuses);
+        }
+        return queryBuilder;
+    }
+    async upsert(knexOrTrx, granule, executionCumulusId, executionPgModel = new execution_1.ExecutionPgModel()) {
         if (!granule.created_at) {
             throw new Error(`To upsert granule record must have 'created_at' set: ${JSON.stringify(granule)}`);
         }
@@ -80,15 +93,16 @@ class GranulePgModel extends base_1.BasePgModel {
             })
                 .where(knexOrTrx.raw(`${this.tableName}.created_at <= to_timestamp(${(0, timestamp_1.translateDateToUTC)(granule.created_at)})`));
             // In reality, the only place where executionCumulusId should be
-            // undefined is from the data migrations
+            // undefined is from the data migrations OR a queued granule from reingest
             if (executionCumulusId) {
-                // Only do the upsert if there IS NOT already a record associating
-                // the granule to this execution. If there IS already a record
-                // linking this granule to this execution, then this upsert query
-                // will not affect any rows.
-                upsertQuery.whereNotExists(granulesExecutionsPgModel.search(knexOrTrx, { execution_cumulus_id: executionCumulusId }));
+                const exclusionClause = this._buildExclusionClause(executionPgModel, executionCumulusId, knexOrTrx, granule.status);
+                // Only do the upsert if there is no execution that matches the exclusionClause
+                // For running granules, this means the execution does not exist in a state other
+                // than 'running'.  For queued granules, this means that the execution does not
+                // exist at all
+                upsertQuery.whereNotExists(exclusionClause);
             }
-            upsertQuery.returning('cumulus_id');
+            upsertQuery.returning('*');
             return await upsertQuery;
         }
         return await knexOrTrx(this.tableName)
@@ -96,7 +110,7 @@ class GranulePgModel extends base_1.BasePgModel {
             .onConflict(['granule_id', 'collection_cumulus_id'])
             .merge()
             .where(knexOrTrx.raw(`${this.tableName}.created_at <= to_timestamp(${(0, timestamp_1.translateDateToUTC)(granule.created_at)})`))
-            .returning('cumulus_id');
+            .returning('*');
     }
     /**
      * Get granules from the granule cumulus_id

package/dist/models/pdr.js

@@ -26,14 +26,14 @@ class PdrPgModel extends base_1.BasePgModel {
                 qb.where(knexOrTrx.raw(`${this.tableName}.execution_cumulus_id != EXCLUDED.execution_cumulus_id`))
                     .orWhere(knexOrTrx.raw(`${this.tableName}.progress < EXCLUDED.progress`));
             })
-                .returning('cumulus_id');
+                .returning('*');
         }
         return await knexOrTrx(this.tableName)
             .insert(pdr)
             .onConflict('name')
             .merge()
             .where(knexOrTrx.raw(`${this.tableName}.created_at <= to_timestamp(${(0, timestamp_1.translateDateToUTC)(pdr.created_at)})`))
-            .returning('cumulus_id');
+            .returning('*');
     }
 }
 exports.default = PdrPgModel;

package/dist/test-utils.js

@@ -58,6 +58,9 @@ const fakeCollectionRecordFactory = (params) => ({
             regex: 'fake-regex',
             sampleFileName: 'file.txt',
         }]),
+    meta: { foo: 'bar' },
+    created_at: new Date(),
+    updated_at: new Date(),
     ...params,
 });
 exports.fakeCollectionRecordFactory = fakeCollectionRecordFactory;

package/dist/translate/async_operations.d.ts

@@ -1,4 +1,17 @@
 import { ApiAsyncOperation } from '@cumulus/types/api/async_operations';
 import { PostgresAsyncOperation } from '../types/async_operation';
+/**
+ * Generate a PostgreSQL Async Operation record from an API record.
+ *
+ * @param {Object} record - An API Async Operation record
+ * @returns {Object} A PostgreSQL Async Operation record
+ */
 export declare const translateApiAsyncOperationToPostgresAsyncOperation: (record: ApiAsyncOperation) => PostgresAsyncOperation;
+/**
+ * Generate an API Async Operation record from a PostgreSQL record.
+ *
+ * @param {Object} pgAsyncOperation - A PostgreSQL async operation record
+ * @returns {Object} An Async Operation API record
+ */
+export declare const translatePostgresAsyncOperationToApiAsyncOperation: (pgAsyncOperation: PostgresAsyncOperation) => ApiAsyncOperation;
 //# sourceMappingURL=async_operations.d.ts.map

package/dist/translate/async_operations.js

@@ -1,7 +1,41 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.translateApiAsyncOperationToPostgresAsyncOperation = void 0;
+exports.translatePostgresAsyncOperationToApiAsyncOperation = exports.translateApiAsyncOperationToPostgresAsyncOperation = void 0;
 const snake_camel_1 = require("snake-camel");
+const logger_1 = __importDefault(require("@cumulus/logger"));
+const log = new logger_1.default({ sender: '@cumulus/db/translate/async-operations' });
+/**
+ *  Convert async operation output field to object
+ * @param {string} output - Record output
+ * @returns {Object}
+ */
+const convertOutputToObject = (output) => {
+    let convertedOutput;
+    try {
+        // First case is intended for an output that is a JSON stringified object
+        convertedOutput = JSON.parse(output);
+        // Second case is intended for an output that is a JSON stringified string or an array
+        if (typeof convertedOutput === 'string' || Array.isArray(convertedOutput)) {
+            log.info(`Converting JSON string ${output} to object to conform to PostgreSQL schema`);
+            convertedOutput = { output: convertedOutput };
+        }
+    }
+    catch (error) {
+        // Third case is for an output that is a string
+        log.error('Converting string to object to conform to PostgreSQL schema', error);
+        convertedOutput = { output };
+    }
+    return convertedOutput;
+};
+/**
+ * Generate a PostgreSQL Async Operation record from an API record.
+ *
+ * @param {Object} record - An API Async Operation record
+ * @returns {Object} A PostgreSQL Async Operation record
+ */
 const translateApiAsyncOperationToPostgresAsyncOperation = (record) => {
     // fix for old implementation of async-operation output assignment
     const translatedRecord = (0, snake_camel_1.toSnake)(record);
@@ -9,7 +43,7 @@ const translateApiAsyncOperationToPostgresAsyncOperation = (record) => {
         delete translatedRecord.output;
     }
     else if (record.output !== undefined) {
-        translatedRecord.output = JSON.parse(JSON.stringify(record.output));
+        translatedRecord.output = convertOutputToObject(record.output);
     }
     if (record.createdAt !== undefined) {
         translatedRecord.created_at = new Date(record.createdAt);
@@ -20,4 +54,24 @@ const translateApiAsyncOperationToPostgresAsyncOperation = (record) => {
     return translatedRecord;
 };
 exports.translateApiAsyncOperationToPostgresAsyncOperation = translateApiAsyncOperationToPostgresAsyncOperation;
+/**
+ * Generate an API Async Operation record from a PostgreSQL record.
+ *
+ * @param {Object} pgAsyncOperation - A PostgreSQL async operation record
+ * @returns {Object} An Async Operation API record
+ */
+const translatePostgresAsyncOperationToApiAsyncOperation = (pgAsyncOperation) => {
+    const apiAsyncOperation = {
+        id: pgAsyncOperation.id,
+        description: pgAsyncOperation.description,
+        operationType: pgAsyncOperation.operation_type,
+        status: pgAsyncOperation.status,
+        output: pgAsyncOperation.output ? JSON.stringify(pgAsyncOperation.output) : undefined,
+        taskArn: pgAsyncOperation.task_arn,
+        createdAt: pgAsyncOperation.created_at ? pgAsyncOperation.created_at.getTime() : undefined,
+        updatedAt: pgAsyncOperation.updated_at ? pgAsyncOperation.updated_at.getTime() : undefined,
+    };
+    return apiAsyncOperation;
+};
+exports.translatePostgresAsyncOperationToApiAsyncOperation = translatePostgresAsyncOperationToApiAsyncOperation;
 //# sourceMappingURL=async_operations.js.map

package/dist/translate/collections.d.ts

@@ -1,4 +1,15 @@
-import { NewCollectionRecord } from '@cumulus/types/api/collections';
-import { PostgresCollection } from '../types/collection';
+import { NewCollectionRecord, CollectionRecord } from '@cumulus/types/api/collections';
+import { PostgresCollection, PostgresCollectionRecord } from '../types/collection';
+/**
+* Translates a PostgresCollectionRecord object to a `CollectionRecord` API collection object
+* @param {PostgresCollectionRecord} collectionRecord - PostgreSQL collection record to translate
+* @returns {CollectionRecord} - Translated record
+*/
+export declare const translatePostgresCollectionToApiCollection: (collectionRecord: PostgresCollectionRecord) => CollectionRecord;
+/**
+* Translates a NewCollectionRecord API collection object to a `PostgresCollectionRecord` object
+* @param {NewCollectionRecord} record - API collection record to translate
+* @returns {PostgresCollectionRecord} - Translated record
+*/
 export declare const translateApiCollectionToPostgresCollection: (record: NewCollectionRecord) => PostgresCollection;
 //# sourceMappingURL=collections.d.ts.map

package/dist/translate/collections.js

@@ -1,6 +1,35 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.translateApiCollectionToPostgresCollection = void 0;
+exports.translateApiCollectionToPostgresCollection = exports.translatePostgresCollectionToApiCollection = void 0;
+const { removeNilProperties } = require('@cumulus/common/util');
+/**
+* Translates a PostgresCollectionRecord object to a `CollectionRecord` API collection object
+* @param {PostgresCollectionRecord} collectionRecord - PostgreSQL collection record to translate
+* @returns {CollectionRecord} - Translated record
+*/
+const translatePostgresCollectionToApiCollection = (collectionRecord) => removeNilProperties(({
+    createdAt: collectionRecord.created_at.getTime(),
+    updatedAt: collectionRecord.updated_at.getTime(),
+    name: collectionRecord.name,
+    version: collectionRecord.version,
+    process: collectionRecord.process,
+    url_path: collectionRecord.url_path,
+    duplicateHandling: collectionRecord.duplicate_handling,
+    granuleId: collectionRecord.granule_id_validation_regex,
+    granuleIdExtraction: collectionRecord.granule_id_extraction_regex,
+    files: collectionRecord.files,
+    reportToEms: collectionRecord.report_to_ems,
+    sampleFileName: collectionRecord.sample_file_name,
+    ignoreFilesConfigForDiscovery: collectionRecord.ignore_files_config_for_discovery,
+    meta: collectionRecord.meta,
+    tags: collectionRecord.tags,
+}));
+exports.translatePostgresCollectionToApiCollection = translatePostgresCollectionToApiCollection;
+/**
+* Translates a NewCollectionRecord API collection object to a `PostgresCollectionRecord` object
+* @param {NewCollectionRecord} record - API collection record to translate
+* @returns {PostgresCollectionRecord} - Translated record
+*/
 const translateApiCollectionToPostgresCollection = (record) => {
     // Map old record to new schema.
     const translatedRecord = {
@@ -16,7 +45,7 @@ const translateApiCollectionToPostgresCollection = (record) => {
         report_to_ems: record.reportToEms,
         sample_file_name: record.sampleFileName,
         ignore_files_config_for_discovery: record.ignoreFilesConfigForDiscovery,
-        meta: (record.meta ? JSON.stringify(record.meta) : undefined),
+        meta: record.meta,
         // have to stringify on an array of values
         tags: (record.tags ? JSON.stringify(record.tags) : undefined),
     };

package/dist/translate/file.js

@@ -23,8 +23,9 @@ const translatePostgresFileToApiFile = (filePgRecord) => removeNilProperties({
     checksumType: filePgRecord.checksum_type,
     fileName: filePgRecord.file_name,
     key: filePgRecord.key,
-    size: filePgRecord.file_size ? filePgRecord.file_size : undefined,
+    size: filePgRecord.file_size ? Number.parseInt(filePgRecord.file_size, 10) : undefined,
     source: filePgRecord.source,
+    type: filePgRecord.type,
 });
 exports.translatePostgresFileToApiFile = translatePostgresFileToApiFile;
 const translateApiFiletoPostgresFile = (file) => {
@@ -39,6 +40,7 @@ const translateApiFiletoPostgresFile = (file) => {
         file_size: file.size,
         path: file.path,
         source: file.source,
+        type: file.type,
     };
 };
 exports.translateApiFiletoPostgresFile = translateApiFiletoPostgresFile;

package/dist/translate/granules.d.ts

@@ -2,16 +2,18 @@ import { Knex } from 'knex';
 import { ApiGranule } from '@cumulus/types/api/granules';
 import { CollectionPgModel } from '../models/collection';
 import { PdrPgModel } from '../models/pdr';
-import { PostgresGranule, PostgresGranuleRecord } from '../types/granule';
 import { ProviderPgModel } from '../models/provider';
 import { FilePgModel } from '../models/file';
 import { PostgresCollectionRecord } from '../types/collection';
+import { PostgresGranule, PostgresGranuleRecord } from '../types/granule';
+import { GranuleWithProviderAndCollectionInfo } from '../types/query';
+import { PostgresProviderRecord } from '../types/provider';
 /**
  * Generate an API Granule object from a Postgres Granule with associated Files.
  *
  * @param {Object} params
  * @param {PostgresGranuleRecord} params.granulePgRecord - Granule from Postgres
- * @param {PostgresCollectionRecord} params.collectionPgRecord - Collection from Postgres
+ * @param {PostgresCollectionRecord} [params.collectionPgRecord] - Optional Collection from Postgres
  * @param {Knex | Knex.Transaction} params.knexOrTransaction
  *   Knex client for reading from RDS database
  * @param {Object} [params.collectionPgModel] - Instance of the collection database model
@@ -20,10 +22,11 @@ import { PostgresCollectionRecord } from '../types/collection';
  * @param {Object} [params.filePgModel] - Instance of the file database model
  * @returns {Object} An API Granule with associated Files
  */
-export declare const translatePostgresGranuleToApiGranule: ({ granulePgRecord, collectionPgRecord, knexOrTransaction, collectionPgModel, pdrPgModel, providerPgModel, filePgModel, }: {
+export declare const translatePostgresGranuleToApiGranule: ({ granulePgRecord, collectionPgRecord, knexOrTransaction, providerPgRecord, collectionPgModel, pdrPgModel, providerPgModel, filePgModel, }: {
     granulePgRecord: PostgresGranuleRecord;
-    collectionPgRecord: PostgresCollectionRecord;
     knexOrTransaction: Knex | Knex.Transaction;
+    collectionPgRecord?: Pick<PostgresCollectionRecord, "name" | "version" | "cumulus_id"> | undefined;
+    providerPgRecord?: Pick<PostgresProviderRecord, "name"> | undefined;
     collectionPgModel?: CollectionPgModel | undefined;
     pdrPgModel?: PdrPgModel | undefined;
     providerPgModel?: ProviderPgModel | undefined;
@@ -42,4 +45,12 @@ export declare const translatePostgresGranuleToApiGranule: ({ granulePgRecord, c
  * @returns {Object} A granule PG record
  */
 export declare const translateApiGranuleToPostgresGranule: (dynamoRecord: AWS.DynamoDB.DocumentClient.AttributeMap, knexOrTransaction: Knex | Knex.Transaction, collectionPgModel?: CollectionPgModel, pdrPgModel?: PdrPgModel, providerPgModel?: ProviderPgModel) => Promise<PostgresGranule>;
+/**
+ * Translate a custom database result into an API granule
+ *
+ * @param {Knex | Knex.Transaction} knex
+ *   Knex client for reading from RDS database
+ * @param {GranuleWithProviderAndCollectionInfo} dbResult - Custom database result
+ */
+export declare const translatePostgresGranuleResultToApiGranule: (knex: Knex, dbResult: GranuleWithProviderAndCollectionInfo) => Promise<ApiGranule>;
 //# sourceMappingURL=granules.d.ts.map

package/dist/translate/granules.js

@@ -1,22 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.translateApiGranuleToPostgresGranule = exports.translatePostgresGranuleToApiGranule = void 0;
+exports.translatePostgresGranuleResultToApiGranule = exports.translateApiGranuleToPostgresGranule = exports.translatePostgresGranuleToApiGranule = void 0;
 const Collections_1 = require("@cumulus/message/Collections");
-const Executions_1 = require("@cumulus/message/Executions");
 const util_1 = require("@cumulus/common/util");
 const errors_1 = require("@cumulus/errors");
 const collection_1 = require("../models/collection");
 const pdr_1 = require("../models/pdr");
 const provider_1 = require("../models/provider");
 const file_1 = require("../models/file");
-const file_2 = require("./file");
 const execution_1 = require("../lib/execution");
+const file_2 = require("./file");
 /**
  * Generate an API Granule object from a Postgres Granule with associated Files.
  *
  * @param {Object} params
  * @param {PostgresGranuleRecord} params.granulePgRecord - Granule from Postgres
- * @param {PostgresCollectionRecord} params.collectionPgRecord - Collection from Postgres
+ * @param {PostgresCollectionRecord} [params.collectionPgRecord] - Optional Collection from Postgres
  * @param {Knex | Knex.Transaction} params.knexOrTransaction
  *   Knex client for reading from RDS database
  * @param {Object} [params.collectionPgModel] - Instance of the collection database model
@@ -25,20 +24,28 @@ const execution_1 = require("../lib/execution");
  * @param {Object} [params.filePgModel] - Instance of the file database model
  * @returns {Object} An API Granule with associated Files
  */
-const translatePostgresGranuleToApiGranule = async ({ granulePgRecord, collectionPgRecord, knexOrTransaction, collectionPgModel = new collection_1.CollectionPgModel(), pdrPgModel = new pdr_1.PdrPgModel(), providerPgModel = new provider_1.ProviderPgModel(), filePgModel = new file_1.FilePgModel(), }) => {
+const translatePostgresGranuleToApiGranule = async ({ granulePgRecord, collectionPgRecord, knexOrTransaction, providerPgRecord, collectionPgModel = new collection_1.CollectionPgModel(), pdrPgModel = new pdr_1.PdrPgModel(), providerPgModel = new provider_1.ProviderPgModel(), filePgModel = new file_1.FilePgModel(), }) => {
     var _a, _b, _c, _d, _e, _f, _g, _h, _j;
     const collection = collectionPgRecord || await collectionPgModel.get(knexOrTransaction, { cumulus_id: granulePgRecord.collection_cumulus_id });
     if (granulePgRecord.collection_cumulus_id !== collection.cumulus_id) {
-        throw new errors_1.ValidationError(`Collection ${collection.cumulus_id} does not match the Granule's Collection ${granulePgRecord.collection_cumulus_id}`);
+        throw new errors_1.ValidationError(`Input collection.cumulus_id: ${collection.cumulus_id} does not match the granule PG record collection_cumulus_id: ${granulePgRecord.collection_cumulus_id}`);
     }
     const files = await filePgModel.search(knexOrTransaction, { granule_cumulus_id: granulePgRecord.cumulus_id });
-    const executionArns = await (0, execution_1.getExecutionArnsByGranuleCumulusId)(knexOrTransaction, granulePgRecord.cumulus_id, 1);
+    const executionUrls = await (0, execution_1.getExecutionInfoByGranuleCumulusId)({
+        knexOrTransaction,
+        granuleCumulusId: granulePgRecord.cumulus_id,
+        executionColumns: ['url'],
+        limit: 1,
+    });
     let pdr;
     if (granulePgRecord.pdr_cumulus_id) {
         pdr = await pdrPgModel.get(knexOrTransaction, { cumulus_id: granulePgRecord.pdr_cumulus_id });
     }
     let provider;
-    if (granulePgRecord.provider_cumulus_id) {
+    if (providerPgRecord) {
+        provider = providerPgRecord;
+    }
+    else if (granulePgRecord.provider_cumulus_id) {
         provider = await providerPgModel.get(knexOrTransaction, { cumulus_id: granulePgRecord.provider_cumulus_id });
     }
     const apiGranule = (0, util_1.removeNilProperties)({
@@ -49,18 +56,15 @@ const translatePostgresGranuleToApiGranule = async ({ granulePgRecord, collectio
         duration: granulePgRecord.duration,
         endingDateTime: (_c = granulePgRecord.ending_date_time) === null || _c === void 0 ? void 0 : _c.toISOString(),
         error: granulePgRecord.error,
-        execution: executionArns[0] ? (0, Executions_1.getExecutionUrlFromArn)(executionArns[0].arn) : undefined,
-        files: files.map((file) => ({
-            ...(0, file_2.translatePostgresFileToApiFile)(file),
-        })),
+        execution: executionUrls[0] ? executionUrls[0].url : undefined,
+        files: files.length > 0 ? files.map((file) => (0, file_2.translatePostgresFileToApiFile)(file)) : undefined,
         granuleId: granulePgRecord.granule_id,
         lastUpdateDateTime: (_d = granulePgRecord.last_update_date_time) === null || _d === void 0 ? void 0 : _d.toISOString(),
         pdrName: pdr ? pdr.name : undefined,
         processingEndDateTime: (_e = granulePgRecord.processing_end_date_time) === null || _e === void 0 ? void 0 : _e.toISOString(),
         processingStartDateTime: (_f = granulePgRecord.processing_start_date_time) === null || _f === void 0 ? void 0 : _f.toISOString(),
         productionDateTime: (_g = granulePgRecord.production_date_time) === null || _g === void 0 ? void 0 : _g.toISOString(),
-        productVolume: granulePgRecord.product_volume
-            ? granulePgRecord.product_volume : undefined,
+        productVolume: granulePgRecord.product_volume,
         provider: provider ? provider.name : undefined,
         published: granulePgRecord.published,
         queryFields: granulePgRecord.query_fields,
@@ -123,4 +127,24 @@ const translateApiGranuleToPostgresGranule = async (dynamoRecord, knexOrTransact
     return granuleRecord;
 };
 exports.translateApiGranuleToPostgresGranule = translateApiGranuleToPostgresGranule;
+/**
+ * Translate a custom database result into an API granule
+ *
+ * @param {Knex | Knex.Transaction} knex
+ *   Knex client for reading from RDS database
+ * @param {GranuleWithProviderAndCollectionInfo} dbResult - Custom database result
+ */
+const translatePostgresGranuleResultToApiGranule = async (knex, dbResult) => await (0, exports.translatePostgresGranuleToApiGranule)({
+    knexOrTransaction: knex,
+    granulePgRecord: dbResult,
+    collectionPgRecord: {
+        cumulus_id: dbResult.collection_cumulus_id,
+        name: dbResult.collectionName,
+        version: dbResult.collectionVersion,
+    },
+    providerPgRecord: {
+        name: dbResult.providerName,
+    },
+});
+exports.translatePostgresGranuleResultToApiGranule = translatePostgresGranuleResultToApiGranule;
 //# sourceMappingURL=granules.js.map

package/dist/translate/pdr.d.ts

@@ -0,0 +1,29 @@
+import { Knex } from 'knex';
+import { ApiPdr } from '@cumulus/types/api/pdrs';
+import { CollectionPgModel } from '../models/collection';
+import { ExecutionPgModel } from '../models/execution';
+import { ProviderPgModel } from '../models/provider';
+import { PostgresPdr, PostgresPdrRecord } from '../types/pdr';
+/**
+ * Generate a Postgres PDR record from a DynamoDB record.
+ *
+ * @param {Object} record - A PDR record
+ * @param {Object} knex - Knex client for reading from RDS database
+ * @param {Object} collectionPgModel - Instance of the collection database model
+ * @param {Object} providerPgModel - Instance of the provider database model
+ * @param {Object} executionPgModel - Instance of the execution database model
+ * @returns {Object} A PDR record
+ */
+export declare const translateApiPdrToPostgresPdr: (record: ApiPdr, knex: Knex, collectionPgModel?: CollectionPgModel, providerPgModel?: ProviderPgModel, executionPgModel?: ExecutionPgModel) => Promise<PostgresPdr>;
+/**
+ * Generate a Postgres PDR record from a DynamoDB record.
+ *
+ * @param {Object} postgresPDR - A Postgres PDR record
+ * @param {Object} knex - Knex client for reading from RDS database
+ * @param {Object} collectionPgModel - Instance of the collection database model
+ * @param {Object} providerPgModel - Instance of the provider database model
+ * @param {Object} executionPgModel - Instance of the execution database model
+ * @returns {Object} A PDR record
+ */
+export declare const translatePostgresPdrToApiPdr: (postgresPDR: PostgresPdrRecord, knex: Knex | Knex.Transaction, collectionPgModel?: CollectionPgModel, providerPgModel?: ProviderPgModel, executionPgModel?: ExecutionPgModel) => Promise<ApiPdr>;
+//# sourceMappingURL=pdr.d.ts.map

package/dist/translate/pdr.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.translatePostgresPdrToApiPdr = exports.translateApiPdrToPostgresPdr = void 0;
+const util_1 = require("@cumulus/common/util");
+const Collections_1 = require("@cumulus/message/Collections");
+const Executions_1 = require("@cumulus/message/Executions");
+const collection_1 = require("../models/collection");
+const execution_1 = require("../models/execution");
+const provider_1 = require("../models/provider");
+/**
+ * Generate a Postgres PDR record from a DynamoDB record.
+ *
+ * @param {Object} record - A PDR record
+ * @param {Object} knex - Knex client for reading from RDS database
+ * @param {Object} collectionPgModel - Instance of the collection database model
+ * @param {Object} providerPgModel - Instance of the provider database model
+ * @param {Object} executionPgModel - Instance of the execution database model
+ * @returns {Object} A PDR record
+ */
+const translateApiPdrToPostgresPdr = async (record, knex, collectionPgModel = new collection_1.CollectionPgModel(), providerPgModel = new provider_1.ProviderPgModel(), executionPgModel = new execution_1.ExecutionPgModel()) => {
+    const { name, version } = (0, Collections_1.deconstructCollectionId)(record.collectionId);
+    const pdrRecord = {
+        name: record.pdrName,
+        status: record.status,
+        provider_cumulus_id: await providerPgModel.getRecordCumulusId(knex, { name: record.provider }),
+        collection_cumulus_id: await collectionPgModel.getRecordCumulusId(knex, { name, version }),
+        execution_cumulus_id: record.execution ? await executionPgModel.getRecordCumulusId(knex, { url: record.execution }) : undefined,
+        progress: record.progress,
+        address: record.address,
+        pan_sent: record.PANSent,
+        pan_message: record.PANmessage,
+        original_url: record.originalUrl,
+        timestamp: record.timestamp ? new Date(record.timestamp) : undefined,
+        duration: record.duration,
+        stats: record.stats,
+        created_at: (record.createdAt ? new Date(record.createdAt) : undefined),
+        updated_at: (record.updatedAt ? new Date(record.updatedAt) : undefined),
+    };
+    return (0, util_1.removeNilProperties)(pdrRecord);
+};
+exports.translateApiPdrToPostgresPdr = translateApiPdrToPostgresPdr;
+/**
+ * Generate a Postgres PDR record from a DynamoDB record.
+ *
+ * @param {Object} postgresPDR - A Postgres PDR record
+ * @param {Object} knex - Knex client for reading from RDS database
+ * @param {Object} collectionPgModel - Instance of the collection database model
+ * @param {Object} providerPgModel - Instance of the provider database model
+ * @param {Object} executionPgModel - Instance of the execution database model
+ * @returns {Object} A PDR record
+ */
+const translatePostgresPdrToApiPdr = async (postgresPDR, knex, collectionPgModel = new collection_1.CollectionPgModel(), providerPgModel = new provider_1.ProviderPgModel(), executionPgModel = new execution_1.ExecutionPgModel()) => {
+    const collection = await collectionPgModel.get(knex, {
+        cumulus_id: postgresPDR.collection_cumulus_id,
+    });
+    const provider = await providerPgModel.get(knex, {
+        cumulus_id: postgresPDR.provider_cumulus_id,
+    });
+    const execution = postgresPDR.execution_cumulus_id ? await executionPgModel.get(knex, {
+        cumulus_id: postgresPDR.execution_cumulus_id,
+    }) : undefined;
+    const apiPdr = {
+        pdrName: postgresPDR.name,
+        provider: provider.name,
+        collectionId: (0, Collections_1.constructCollectionId)(collection.name, collection.version),
+        status: postgresPDR.status,
+        createdAt: postgresPDR.created_at.getTime(),
+        progress: postgresPDR.progress,
+        execution: execution ? (0, Executions_1.getExecutionUrlFromArn)(execution.arn) : undefined,
+        PANSent: postgresPDR.pan_sent,
+        PANmessage: postgresPDR.pan_message,
+        stats: postgresPDR.stats,
+        address: postgresPDR.address,
+        originalUrl: postgresPDR.original_url,
+        timestamp: (postgresPDR.timestamp ? postgresPDR.timestamp.getTime() : undefined),
+        duration: postgresPDR.duration,
+        updatedAt: postgresPDR.updated_at.getTime(),
+    };
+    return (0, util_1.removeNilProperties)(apiPdr);
+};
+exports.translatePostgresPdrToApiPdr = translatePostgresPdrToApiPdr;
+//# sourceMappingURL=pdr.js.map

package/dist/translate/providers.d.ts

@@ -1,6 +1,7 @@
 import { ApiProvider } from '@cumulus/types';
-import { PostgresProvider } from '../types/provider';
+import { PostgresProvider, PostgresProviderRecord } from '../types/provider';
 export declare const encryptValueWithKMS: (value: string, encryptFunction?: Function) => Promise<string>;
+export declare const translatePostgresProviderToApiProvider: (record: PostgresProviderRecord) => ApiProvider;
 /**
 * Translates API Provider record to Postgres Provider record
 *

package/dist/translate/providers.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.translateApiProviderToPostgresProvider = exports.encryptValueWithKMS = void 0;
+exports.translateApiProviderToPostgresProvider = exports.translatePostgresProviderToApiProvider = exports.encryptValueWithKMS = void 0;
+const util_1 = require("@cumulus/common/util");
 const common_1 = require("@cumulus/common");
 const aws_client_1 = require("@cumulus/aws-client");
 const encryptValueWithKMS = (value, encryptFunction = aws_client_1.KMS.encrypt) => {
@@ -8,6 +9,28 @@ const encryptValueWithKMS = (value, encryptFunction = aws_client_1.KMS.encrypt)
     return encryptFunction(providerKmsKeyId, value);
 };
 exports.encryptValueWithKMS = encryptValueWithKMS;
+const translatePostgresProviderToApiProvider = (record) => {
+    const apiProvider = {
+        id: record.name,
+        cmKeyId: record.cm_key_id,
+        certificateUri: record.certificate_uri,
+        privateKey: record.private_key,
+        globalConnectionLimit: record.global_connection_limit,
+        port: record.port,
+        host: record.host,
+        protocol: record.protocol,
+        createdAt: record.created_at.getTime(),
+        updatedAt: record.updated_at.getTime(),
+        username: record.username,
+        password: record.password,
+        allowedRedirects: record.allowed_redirects,
+    };
+    if (record.username || record.password) {
+        apiProvider.encrypted = true;
+    }
+    return (0, util_1.removeNilProperties)(apiProvider);
+};
+exports.translatePostgresProviderToApiProvider = translatePostgresProviderToApiProvider;
 /**
 * Translates API Provider record to Postgres Provider record
 *

package/dist/translate/rules.d.ts

@@ -2,7 +2,8 @@ import { Knex } from 'knex';
 import { RuleRecord } from '@cumulus/types/api/rules';
 import { CollectionPgModel } from '../models/collection';
 import { ProviderPgModel } from '../models/provider';
-import { PostgresRule } from '../types/rule';
+import { PostgresRule, PostgresRuleRecord } from '../types/rule';
+export declare const translatePostgresRuleToApiRule: (pgRule: PostgresRuleRecord, knex: Knex | Knex.Transaction, collectionPgModel?: CollectionPgModel, providerPgModel?: ProviderPgModel) => Promise<RuleRecord>;
 /**
  * Generate a Postgres rule record from a DynamoDB record.
  *