@cumulus/db 21.3.1 → 21.3.2-testlerna.0

package/dist/search/GranuleSearch.js

@@ -17,9 +17,9 @@ const log = new logger_1.default({ sender: '@cumulus/db/GranuleSearch' });
  * Class to build and execute db search query for granules
  */
 class GranuleSearch extends BaseSearch_1.BaseSearch {
-    constructor(event) {
+    constructor(event, enableEstimate = true) {
         // estimate the table rowcount by default
-        if (event?.queryStringParameters?.estimateTableRowCount !== 'false') {
+        if (enableEstimate && event?.queryStringParameters?.estimateTableRowCount !== 'false') {
             (0, set_1.default)(event, 'queryStringParameters.estimateTableRowCount', 'true');
         }
         super(event, 'granule');
@@ -33,7 +33,7 @@ class GranuleSearch extends BaseSearch_1.BaseSearch {
     buildBasicQuery(knex) {
         const { collections: collectionsTable, providers: providersTable, pdrs: pdrsTable, } = tables_1.TableNames;
         const countQuery = knex(this.tableName)
-            .count('*');
+            .count('* as count');
         const searchQuery = knex(this.tableName)
             .select(`${this.tableName}.*`)
             .select({

package/dist/search/PdrSearch.js

@@ -26,7 +26,7 @@ class PdrSearch extends BaseSearch_1.BaseSearch {
     buildBasicQuery(knex) {
         const { collections: collectionsTable, providers: providersTable, executions: executionsTable, } = tables_1.TableNames;
         const countQuery = knex(this.tableName)
-            .count('*');
+            .count('* as count');
         const searchQuery = knex(this.tableName)
             .select(`${this.tableName}.*`)
             .select({

package/dist/search/ReconciliationReportSearch.js

@@ -26,7 +26,7 @@ class ReconciliationReportSearch extends BaseSearch_1.BaseSearch {
     buildBasicQuery(knex) {
         const { reconciliationReports: reconciliationReportsTable, } = tables_1.TableNames;
         const countQuery = knex(this.tableName)
-            .count('*');
+            .count('* as count');
         const searchQuery = knex(this.tableName)
             .select(`${this.tableName}.*`)
             .select({

package/dist/search/RuleSearch.js

@@ -26,7 +26,7 @@ class RuleSearch extends BaseSearch_1.BaseSearch {
     buildBasicQuery(knex) {
         const { collections: collectionsTable, providers: providersTable, } = tables_1.TableNames;
         const countQuery = knex(this.tableName)
-            .count(`${this.tableName}.cumulus_id`);
+            .count('* as count');
         const searchQuery = knex(this.tableName)
             .select(`${this.tableName}.*`)
             .select({
@@ -77,18 +77,18 @@ class RuleSearch extends BaseSearch_1.BaseSearch {
     */
     async translatePostgresRecordsToApiRecords(pgRecords) {
         log.debug(`translatePostgresRecordsToApiRecords number of records ${pgRecords.length} `);
-        const apiRecords = pgRecords.map(async (record) => {
+        const apiRecords = pgRecords.map((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);
+            const apiRecord = (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);
+        return apiRecords;
     }
 }
 exports.RuleSearch = RuleSearch;

package/dist/search/StatsSearch.d.ts

@@ -1,6 +1,16 @@
 import { Knex } from 'knex';
 import { DbQueryParameters, QueryEvent } from '../types/search';
 import { BaseSearch } from './BaseSearch';
+export declare type TotalSummary = {
+    count_errors: number;
+    count_collections: number;
+    count_granules: number;
+    avg_processing_time: number;
+};
+declare type Aggregate = {
+    count: string;
+    aggregatedfield: string;
+};
 declare type Summary = {
     dateFrom: string;
     dateTo: string;
@@ -8,7 +18,7 @@ declare type Summary = {
     aggregation: string;
     unit: string;
 };
-declare type SummaryResult = {
+export declare type SummaryResult = {
     errors: Summary;
     granules: Summary;
     collections: Summary;
@@ -23,7 +33,7 @@ declare type AggregateRes = {
     key: string;
     count: number;
 };
-declare type ApiAggregateResult = {
+export declare type ApiAggregateResult = {
     meta: Meta;
     count: AggregateRes[];
 };
@@ -39,14 +49,15 @@ declare class StatsSearch extends BaseSearch {
      * @param result - the postgres query results
      * @returns the api object with the aggregate statistics
      */
-    private formatAggregateResult;
+    protected formatAggregateResult(result: Record<string, Aggregate>): ApiAggregateResult;
     /**
      * Formats the postgres results into an API stats/summary response
      *
      * @param result - the knex summary query results
      * @returns the api object with the summary statistics
      */
-    private formatSummaryResult;
+    protected formatSummaryResult(result: TotalSummary): SummaryResult;
+    protected buildSummaryQuery(knex: Knex): Knex.QueryBuilder;
     /**
      * Queries postgres for a summary of statistics around the granules in the system
      *

package/dist/search/StatsSearch.js

@@ -94,6 +94,12 @@ class StatsSearch extends BaseSearch_1.BaseSearch {
             },
         };
     }
+    buildSummaryQuery(knex) {
+        const aggregateQuery = knex(this.tableName);
+        this.buildRangeQuery({ searchQuery: aggregateQuery });
+        aggregateQuery.select(knex.raw(`COUNT(CASE WHEN ${this.tableName}.error ->> 'Error' is not null THEN 1 END) AS count_errors`), knex.raw('COUNT(*) AS count_granules'), knex.raw(`AVG(${this.tableName}.duration) AS avg_processing_time`), knex.raw(`COUNT(DISTINCT ${this.tableName}.collection_cumulus_id) AS count_collections`));
+        return aggregateQuery;
+    }
     /**
      * Queries postgres for a summary of statistics around the granules in the system
      *
@@ -102,9 +108,7 @@ class StatsSearch extends BaseSearch_1.BaseSearch {
      */
     async summary(testKnex) {
         const knex = testKnex ?? await (0, connection_1.getKnexClient)();
-        const aggregateQuery = knex(this.tableName);
-        this.buildRangeQuery({ searchQuery: aggregateQuery });
-        aggregateQuery.select(knex.raw(`COUNT(CASE WHEN ${this.tableName}.error ->> 'Error' is not null THEN 1 END) AS count_errors`), knex.raw('COUNT(*) AS count_granules'), knex.raw(`AVG(${this.tableName}.duration) AS avg_processing_time`), knex.raw(`COUNT(DISTINCT ${this.tableName}.collection_cumulus_id) AS count_collections`));
+        const aggregateQuery = this.buildSummaryQuery(knex);
         log.debug(`summary about to execute query: ${aggregateQuery?.toSQL().sql}`);
         const aggregateQueryRes = await aggregateQuery;
         return this.formatSummaryResult(aggregateQueryRes[0]);
@@ -133,11 +137,13 @@ class StatsSearch extends BaseSearch_1.BaseSearch {
      * @param knex - the knex client to be used
      */
     aggregateQueryField(query, knex) {
-        if (this.field?.includes('error.Error')) {
-            query.select(knex.raw("error ->> 'Error' as aggregatedfield"));
+        const normalizedKey = this.field === 'error.Error.keyword' ? 'error.Error' : this.field;
+        if (normalizedKey?.includes('.')) {
+            const [root, ...nested] = normalizedKey.split('.');
+            query.select(knex.raw(`${root} ->> '${nested.join('.')}' as aggregatedfield`));
         }
         else {
-            query.select(`${this.tableName}.${this.field} as aggregatedfield`);
+            query.select(`${this.tableName}.${normalizedKey} as aggregatedfield`);
         }
         query.modify((queryBuilder) => this.joinTables(queryBuilder))
             .count('* as count')

package/dist/search/field-mapping.d.ts

@@ -10,7 +10,5 @@
 export declare const mapQueryStringFieldToDbField: (type: string, queryField: {
     name: string;
     value?: string;
-}) => {
-    [key: string]: any;
-} | undefined;
+}) => Record<string, any> | undefined;
 //# sourceMappingURL=field-mapping.d.ts.map

package/dist/search/field-mapping.js

@@ -10,7 +10,7 @@ const log = new logger_1.default({ sender: '@cumulus/db/field-mapping' });
 // functions to map the api search string field name and value to postgres db field
 const granuleMapping = {
     archived: (value) => ({
-        archived: value,
+        archived: value === 'true',
     }),
     beginningDateTime: (value) => ({
         beginning_date_time: value,
@@ -72,13 +72,6 @@ const granuleMapping = {
     error: (value) => ({
         error: value,
     }),
-    // nested error field
-    'error.Error': (value) => ({
-        'error.Error': value,
-    }),
-    'error.Error.keyword': (value) => ({
-        'error.Error': value,
-    }),
     // The following fields require querying other tables
     collectionId: (value) => {
         const { name, version } = (value && (0, Collections_1.deconstructCollectionId)(value)) || {};
@@ -175,13 +168,6 @@ const executionMapping = {
     duration: (value) => ({
         duration: value && Number(value),
     }),
-    // nested error field
-    'error.Error': (value) => ({
-        'error.Error': value,
-    }),
-    'error.Error.keyword': (value) => ({
-        'error.Error': value,
-    }),
     execution: (value) => ({
         url: value,
     }),
@@ -212,7 +198,7 @@ const executionMapping = {
         };
     },
     archived: (value) => ({
-        archived: value,
+        archived: value === 'true',
     }),
 };
 const pdrMapping = {
@@ -386,6 +372,12 @@ const reconciliationReportMapping = {
         updated_at: value && new Date(Number(value)),
     }),
 };
+const nestedRootsByType = {
+    execution: new Set(['error']),
+    granule: new Set(['error', 'queryFields']),
+    pdr: new Set(['stats']),
+    reconciliationReport: new Set(['error']),
+};
 // type and its mapping
 const supportedMappings = {
     granule: granuleMapping,
@@ -397,6 +389,19 @@ const supportedMappings = {
     rule: ruleMapping,
     reconciliationReport: reconciliationReportMapping,
 };
+const toSnakeCase = (str) => str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+const mapNestedKey = (type, key) => {
+    const normalizedKey = key === 'error.Error.keyword' ? 'error.Error' : key;
+    const [root, ...nested] = normalizedKey.split('.');
+    const allowedRoots = nestedRootsByType[type];
+    if (!allowedRoots || !allowedRoots.has(root)) {
+        return undefined;
+    }
+    const mappedRoot = toSnakeCase(root);
+    if (nested.length === 0)
+        return mappedRoot;
+    return [mappedRoot, ...nested].join('.');
+};
 /**
  * Map query string field to db field
  *
@@ -407,11 +412,27 @@ const supportedMappings = {
  * @returns db field
  */
 const mapQueryStringFieldToDbField = (type, queryField) => {
-    if (!(supportedMappings[type] && supportedMappings[type][queryField.name])) {
-        log.warn(`No db mapping field found for type: ${type}, field ${JSON.stringify(queryField)}`);
+    const typeMapping = supportedMappings[type];
+    if (!typeMapping) {
+        log.warn(`No mapping found for type: ${type}`);
         return undefined;
     }
-    return supportedMappings[type] && supportedMappings[type][queryField.name](queryField.value);
+    // Exact match (typed + custom logic)
+    const exactMapper = typeMapping[queryField.name];
+    if (exactMapper) {
+        return exactMapper(queryField.value);
+    }
+    // Nested fallback with type inference
+    if (queryField.name.includes('.')) {
+        const mappedKey = mapNestedKey(type, queryField.name);
+        if (mappedKey) {
+            return {
+                [mappedKey]: queryField.value,
+            };
+        }
+    }
+    log.warn(`No db mapping field found for type: ${type}, field ${JSON.stringify(queryField)}`);
+    return undefined;
 };
 exports.mapQueryStringFieldToDbField = mapQueryStringFieldToDbField;
 //# sourceMappingURL=field-mapping.js.map

package/dist/test-duckdb-utils.d.ts

@@ -0,0 +1,31 @@
+import type { Knex } from 'knex';
+import { DuckDBInstance, DuckDBConnection } from '@duckdb/node-api';
+/**
+ * Creates a DuckDB in-memory instance and sets up S3/httpfs for testing.
+ * Configures S3-related settings on the DuckDB instance.
+ *
+ * @param {string} dbFilePath - The path to the DuckDB database file. Defaults to in-memory
+ * @returns {Promise<{ instance: DuckDBInstance, connection: DuckDBConnection }>}
+ *   - The created DuckDB instance and the connection object for interacting with the database.
+ *   - The connection is configured with HTTPFS for S3.
+ */
+export declare function setupDuckDBWithS3ForTesting(dbFilePath?: string): Promise<{
+    instance: DuckDBInstance;
+    connection: DuckDBConnection;
+}>;
+/**
+ * Stages data into a temporary DuckDB table, exports it to Parquet (S3),
+ * and then loads it into the target table.
+ *
+ * @template T - Shape of the row object being inserted.
+ * @param connection - Active DuckDB connection.
+ * @param knexBuilder - Knex instance used to generate SQL insert statements.
+ * @param tableName - Name of the destination table.
+ * @param tableSql - Function that returns the CREATE TABLE SQL for a given table name.
+ * @param data - A single row or array of rows to insert.
+ * @param s3Path - Destination S3 path where the staged data will be exported as Parquet.
+ * @returns Promise that resolves when the staging, export, and load process completes.
+ */
+export declare function stageAndLoadDuckDBTableFromData<T extends Record<string, any>>(connection: DuckDBConnection, knexBuilder: Knex, tableName: string, tableSql: (tableName: string) => string, data: T | T[], s3Path: string): Promise<void>;
+export declare function createDuckDBTables(connection: DuckDBConnection): Promise<void>;
+//# sourceMappingURL=test-duckdb-utils.d.ts.map

package/dist/test-duckdb-utils.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDuckDBTables = exports.stageAndLoadDuckDBTableFromData = exports.setupDuckDBWithS3ForTesting = void 0;
+const node_api_1 = require("@duckdb/node-api");
+const s3TableSchemas_1 = require("./s3search/s3TableSchemas");
+const duckdbHelpers_1 = require("./s3search/duckdbHelpers");
+/**
+ * Creates a DuckDB in-memory instance and sets up S3/httpfs for testing.
+ * Configures S3-related settings on the DuckDB instance.
+ *
+ * @param {string} dbFilePath - The path to the DuckDB database file. Defaults to in-memory
+ * @returns {Promise<{ instance: DuckDBInstance, connection: DuckDBConnection }>}
+ *   - The created DuckDB instance and the connection object for interacting with the database.
+ *   - The connection is configured with HTTPFS for S3.
+ */
+async function setupDuckDBWithS3ForTesting(dbFilePath = ':memory:') {
+    const instance = await node_api_1.DuckDBInstance.create(dbFilePath);
+    const connection = await instance.connect();
+    // Configure DuckDB HTTPFS for S3
+    await connection.run(`
+    INSTALL httpfs;
+    LOAD httpfs;
+    SET s3_region='us-east-1';
+    SET s3_access_key_id='test';
+    SET s3_secret_access_key='test';
+    SET s3_endpoint='localhost:4566';
+    SET s3_use_ssl=false;
+    SET s3_url_style='path';
+  `);
+    return { instance, connection };
+}
+exports.setupDuckDBWithS3ForTesting = setupDuckDBWithS3ForTesting;
+/**
+ * Stages data into a temporary DuckDB table, exports it to Parquet (S3),
+ * and then loads it into the target table.
+ *
+ * @template T - Shape of the row object being inserted.
+ * @param connection - Active DuckDB connection.
+ * @param knexBuilder - Knex instance used to generate SQL insert statements.
+ * @param tableName - Name of the destination table.
+ * @param tableSql - Function that returns the CREATE TABLE SQL for a given table name.
+ * @param data - A single row or array of rows to insert.
+ * @param s3Path - Destination S3 path where the staged data will be exported as Parquet.
+ * @returns Promise that resolves when the staging, export, and load process completes.
+ */
+async function stageAndLoadDuckDBTableFromData(connection, knexBuilder, tableName, tableSql, data, s3Path) {
+    if (!data || (Array.isArray(data) && data.length === 0))
+        return;
+    const rows = Array.isArray(data) ? data : [data];
+    const tmpTableName = `${tableName}_tmp`;
+    // Create temporary staging table
+    await connection.run(tableSql(tmpTableName));
+    // Insert into staging table
+    if (tableName === 'executions') {
+        const execRows = rows;
+        const parentRows = execRows.filter((r) => !r.parent_cumulus_id);
+        const childRows = execRows.filter((r) => r.parent_cumulus_id);
+        if (parentRows.length > 0) {
+            const parentInsert = knexBuilder(tmpTableName)
+                .insert(parentRows)
+                .toSQL()
+                .toNative();
+            await connection.run(parentInsert.sql, (0, duckdbHelpers_1.prepareBindings)(parentInsert.bindings));
+        }
+        if (childRows.length > 0) {
+            const childInsert = knexBuilder(tmpTableName)
+                .insert(childRows)
+                .toSQL()
+                .toNative();
+            await connection.run(childInsert.sql, (0, duckdbHelpers_1.prepareBindings)(childInsert.bindings));
+        }
+    }
+    else {
+        // Generic insert for other tables
+        const insertQuery = knexBuilder(tmpTableName)
+            .insert(rows)
+            .toSQL()
+            .toNative();
+        await connection.run(insertQuery.sql, (0, duckdbHelpers_1.prepareBindings)(insertQuery.bindings));
+    }
+    // Export staging table to Parquet (S3)
+    await connection.run(`
+    COPY ${tmpTableName}
+    TO '${s3Path}'
+    (FORMAT PARQUET);
+  `);
+    // Load from staging table into final table
+    if (tableName === 'executions') {
+        // Insert parents first
+        await connection.run(`
+      INSERT INTO ${tableName}
+      SELECT * FROM ${tmpTableName}
+      WHERE parent_cumulus_id IS NULL;
+    `);
+        // Insert children next
+        await connection.run(`
+      INSERT INTO ${tableName}
+      SELECT * FROM ${tmpTableName}
+      WHERE parent_cumulus_id IS NOT NULL;
+    `);
+    }
+    else {
+        await connection.run(`
+      INSERT INTO ${tableName}
+      SELECT * FROM ${tmpTableName};
+    `);
+    }
+    //  Drop staging table
+    await connection.run(`DROP TABLE IF EXISTS ${tmpTableName};`);
+}
+exports.stageAndLoadDuckDBTableFromData = stageAndLoadDuckDBTableFromData;
+async function createDuckDBTables(connection) {
+    await connection.run((0, s3TableSchemas_1.asyncOperationsS3TableSql)());
+    await connection.run((0, s3TableSchemas_1.collectionsS3TableSql)());
+    await connection.run((0, s3TableSchemas_1.providersS3TableSql)());
+    await connection.run((0, s3TableSchemas_1.granulesS3TableSql)());
+    await connection.run((0, s3TableSchemas_1.filesS3TableSql)());
+    await connection.run((0, s3TableSchemas_1.executionsS3TableSql)());
+    await connection.run((0, s3TableSchemas_1.granulesExecutionsS3TableSql)());
+    await connection.run((0, s3TableSchemas_1.pdrsS3TableSql)());
+    await connection.run((0, s3TableSchemas_1.reconciliationReportsS3TableSql)());
+    await connection.run((0, s3TableSchemas_1.rulesS3TableSql)());
+}
+exports.createDuckDBTables = createDuckDBTables;
+//# sourceMappingURL=test-duckdb-utils.js.map

package/dist/test-utils.js

@@ -94,12 +94,15 @@ const fakeGranuleRecordFactory = (params) => ({
     producer_granule_id: (0, crypto_random_string_1.default)({ length: 5 }),
     status: 'completed',
     created_at: new Date(),
+    updated_at: new Date(),
     ...params,
 });
 exports.fakeGranuleRecordFactory = fakeGranuleRecordFactory;
 const fakeFileRecordFactory = (params) => ({
     bucket: (0, crypto_random_string_1.default)({ length: 3 }),
     key: (0, crypto_random_string_1.default)({ length: 3 }),
+    created_at: new Date(),
+    updated_at: new Date(),
     ...params,
 });
 exports.fakeFileRecordFactory = fakeFileRecordFactory;
@@ -110,6 +113,8 @@ const fakeAsyncOperationRecordFactory = (params) => ({
     status: 'RUNNING',
     output: { test: 'output' },
     task_arn: (0, crypto_random_string_1.default)({ length: 3 }),
+    created_at: new Date(),
+    updated_at: new Date(),
     ...params,
 });
 exports.fakeAsyncOperationRecordFactory = fakeAsyncOperationRecordFactory;
@@ -117,6 +122,7 @@ const fakePdrRecordFactory = (params) => ({
     name: `pdr${(0, crypto_random_string_1.default)({ length: 10 })}`,
     status: 'running',
     created_at: new Date(),
+    updated_at: new Date(),
     ...params,
 });
 exports.fakePdrRecordFactory = fakePdrRecordFactory;

package/dist/translate/async_operations.js

@@ -4,8 +4,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.translatePostgresAsyncOperationToApiAsyncOperation = exports.translateApiAsyncOperationToPostgresAsyncOperation = void 0;
+const isObject_1 = __importDefault(require("lodash/isObject"));
 const omit_1 = __importDefault(require("lodash/omit"));
 const snake_camel_1 = require("snake-camel");
+const util_1 = require("@cumulus/common/util");
 const logger_1 = __importDefault(require("@cumulus/logger"));
 const log = new logger_1.default({ sender: '@cumulus/db/translate/async-operations' });
 /**
@@ -67,10 +69,12 @@ const translatePostgresAsyncOperationToApiAsyncOperation = (pgAsyncOperation) =>
         description: pgAsyncOperation.description,
         operationType: pgAsyncOperation.operation_type,
         status: pgAsyncOperation.status,
-        output: pgAsyncOperation.output ? JSON.stringify(pgAsyncOperation.output) : undefined,
+        output: (0, isObject_1.default)(pgAsyncOperation.output)
+            ? JSON.stringify(pgAsyncOperation.output)
+            : pgAsyncOperation.output,
         taskArn: pgAsyncOperation.task_arn,
-        createdAt: pgAsyncOperation.created_at ? pgAsyncOperation.created_at.getTime() : undefined,
-        updatedAt: pgAsyncOperation.updated_at ? pgAsyncOperation.updated_at.getTime() : undefined,
+        createdAt: (0, util_1.returnNullOrUndefinedOrDate)(pgAsyncOperation.created_at)?.getTime(),
+        updatedAt: (0, util_1.returnNullOrUndefinedOrDate)(pgAsyncOperation.created_at)?.getTime(),
     };
     return apiAsyncOperation;
 };

package/dist/translate/collections.js

@@ -1,15 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.translateApiCollectionToPostgresCollection = exports.translatePostgresCollectionToApiCollection = void 0;
-const { removeNilProperties } = require('@cumulus/common/util');
+const { parseIfJson, returnNullOrUndefinedOrDate, 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(),
+    createdAt: returnNullOrUndefinedOrDate(collectionRecord.created_at).getTime(),
+    updatedAt: returnNullOrUndefinedOrDate(collectionRecord.updated_at).getTime(),
     name: collectionRecord.name,
     version: collectionRecord.version,
     process: collectionRecord.process,
@@ -17,12 +17,12 @@ const translatePostgresCollectionToApiCollection = (collectionRecord) => removeN
     duplicateHandling: collectionRecord.duplicate_handling,
     granuleId: collectionRecord.granule_id_validation_regex,
     granuleIdExtraction: collectionRecord.granule_id_extraction_regex,
-    files: collectionRecord.files,
+    files: parseIfJson(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,
+    meta: parseIfJson(collectionRecord.meta),
+    tags: parseIfJson(collectionRecord.tags),
 }));
 exports.translatePostgresCollectionToApiCollection = translatePostgresCollectionToApiCollection;
 /**

package/dist/translate/executions.js

@@ -24,10 +24,10 @@ const translatePostgresExecutionToApiExecutionWithoutDbQuery = ({ executionRecor
         status: executionRecord.status,
         arn: executionRecord.arn,
         duration: executionRecord.duration,
-        error: executionRecord.error,
-        tasks: executionRecord.tasks,
-        originalPayload: executionRecord.original_payload,
-        finalPayload: executionRecord.final_payload,
+        error: (0, util_1.parseIfJson)(executionRecord.error),
+        tasks: (0, util_1.parseIfJson)(executionRecord.tasks),
+        originalPayload: (0, util_1.parseIfJson)(executionRecord.original_payload),
+        finalPayload: (0, util_1.parseIfJson)(executionRecord.final_payload),
         type: executionRecord.workflow_name,
         execution: executionRecord.url,
         cumulusVersion: executionRecord.cumulus_version,
@@ -35,9 +35,9 @@ const translatePostgresExecutionToApiExecutionWithoutDbQuery = ({ executionRecor
         collectionId,
         parentArn,
         archived: executionRecord.archived,
-        createdAt: executionRecord.created_at.getTime(),
-        updatedAt: executionRecord.updated_at.getTime(),
-        timestamp: executionRecord.timestamp?.getTime(),
+        createdAt: (0, util_1.returnNullOrUndefinedOrDate)(executionRecord.created_at)?.getTime(),
+        updatedAt: (0, util_1.returnNullOrUndefinedOrDate)(executionRecord.updated_at)?.getTime(),
+        timestamp: (0, util_1.returnNullOrUndefinedOrDate)(executionRecord.timestamp)?.getTime(),
     };
     return (0, util_1.removeNilProperties)(translatedRecord);
 };

package/dist/translate/granules.js

@@ -30,31 +30,36 @@ const file_2 = require("./file");
  */
 const translatePostgresGranuleToApiGranuleWithoutDbQuery = ({ granulePgRecord, collectionPgRecord, executionUrls = [], files = [], pdr, providerPgRecord, }) => (0, util_1.removeNilProperties)({
     archived: granulePgRecord.archived,
-    beginningDateTime: granulePgRecord.beginning_date_time?.toISOString(),
+    beginningDateTime: (0, util_1.returnNullOrUndefinedOrDate)(granulePgRecord.beginning_date_time)
+        ?.toISOString(),
     cmrLink: granulePgRecord.cmr_link,
     collectionId: (0, Collections_1.constructCollectionId)(collectionPgRecord.name, collectionPgRecord.version),
-    createdAt: granulePgRecord.created_at?.getTime(),
+    createdAt: new Date(granulePgRecord.created_at)?.getTime(),
     duration: granulePgRecord.duration,
-    endingDateTime: granulePgRecord.ending_date_time?.toISOString(),
-    error: granulePgRecord.error,
+    endingDateTime: (0, util_1.returnNullOrUndefinedOrDate)(granulePgRecord.ending_date_time)?.toISOString(),
+    error: (0, util_1.parseIfJson)(granulePgRecord.error),
     execution: executionUrls[0] ? executionUrls[0].url : undefined,
     files: files.length > 0 ? files.map((file) => (0, file_2.translatePostgresFileToApiFile)(file)) : [],
     granuleId: granulePgRecord.granule_id,
-    lastUpdateDateTime: granulePgRecord.last_update_date_time?.toISOString(),
+    lastUpdateDateTime: (0, util_1.returnNullOrUndefinedOrDate)(granulePgRecord.last_update_date_time)
+        ?.toISOString(),
     pdrName: pdr ? pdr.name : undefined,
-    processingEndDateTime: granulePgRecord.processing_end_date_time?.toISOString(),
-    processingStartDateTime: granulePgRecord.processing_start_date_time?.toISOString(),
+    processingEndDateTime: (0, util_1.returnNullOrUndefinedOrDate)(granulePgRecord.processing_end_date_time)
+        ?.toISOString(),
+    processingStartDateTime: (0, util_1.returnNullOrUndefinedOrDate)(granulePgRecord.processing_start_date_time)
+        ?.toISOString(),
     producerGranuleId: granulePgRecord.producer_granule_id,
-    productionDateTime: granulePgRecord.production_date_time?.toISOString(),
+    productionDateTime: (0, util_1.returnNullOrUndefinedOrDate)(granulePgRecord.production_date_time)
+        ?.toISOString(),
     productVolume: granulePgRecord.product_volume,
     provider: providerPgRecord ? providerPgRecord.name : undefined,
     published: granulePgRecord.published,
-    queryFields: granulePgRecord.query_fields,
+    queryFields: (0, util_1.parseIfJson)(granulePgRecord.query_fields),
     status: granulePgRecord.status,
-    timestamp: granulePgRecord.timestamp?.getTime(),
+    timestamp: (0, util_1.returnNullOrUndefinedOrDate)(granulePgRecord.timestamp)?.getTime(),
     timeToArchive: granulePgRecord.time_to_archive,
     timeToPreprocess: granulePgRecord.time_to_process,
-    updatedAt: granulePgRecord.updated_at?.getTime(),
+    updatedAt: new Date(granulePgRecord.updated_at)?.getTime(),
 });
 exports.translatePostgresGranuleToApiGranuleWithoutDbQuery = translatePostgresGranuleToApiGranuleWithoutDbQuery;
 /**

package/dist/translate/pdr.js

@@ -55,17 +55,17 @@ const translatePostgresPdrToApiPdrWithoutDbQuery = ({ pdrPgRecord, collectionPgR
     provider: providerPgRecord?.name,
     collectionId: (0, Collections_1.constructCollectionId)(collectionPgRecord.name, collectionPgRecord.version),
     status: pdrPgRecord.status,
-    createdAt: pdrPgRecord.created_at.getTime(),
+    createdAt: (0, util_1.returnNullOrUndefinedOrDate)(pdrPgRecord.created_at)?.getTime(),
     progress: pdrPgRecord.progress,
     execution: executionArn ? (0, Executions_1.getExecutionUrlFromArn)(executionArn) : undefined,
     PANSent: pdrPgRecord.pan_sent,
     PANmessage: pdrPgRecord.pan_message,
-    stats: pdrPgRecord.stats,
+    stats: (0, util_1.parseIfJson)(pdrPgRecord.stats),
     address: pdrPgRecord.address,
     originalUrl: pdrPgRecord.original_url,
-    timestamp: (pdrPgRecord.timestamp ? pdrPgRecord.timestamp.getTime() : undefined),
+    timestamp: (0, util_1.returnNullOrUndefinedOrDate)(pdrPgRecord.timestamp)?.getTime(),
     duration: pdrPgRecord.duration,
-    updatedAt: pdrPgRecord.updated_at.getTime(),
+    updatedAt: (0, util_1.returnNullOrUndefinedOrDate)(pdrPgRecord.updated_at)?.getTime(),
 });
 exports.translatePostgresPdrToApiPdrWithoutDbQuery = translatePostgresPdrToApiPdrWithoutDbQuery;
 /**

package/dist/translate/providers.js

@@ -20,8 +20,8 @@ const translatePostgresProviderToApiProvider = (record) => {
         port: record.port,
         host: record.host,
         protocol: record.protocol,
-        createdAt: record.created_at.getTime(),
-        updatedAt: record.updated_at.getTime(),
+        createdAt: (0, util_1.returnNullOrUndefinedOrDate)(record.created_at)?.getTime(),
+        updatedAt: (0, util_1.returnNullOrUndefinedOrDate)(record.updated_at)?.getTime(),
         username: record.username,
         password: record.password,
         allowedRedirects: record.allowed_redirects,