@cumulus/db 21.3.1 → 21.3.2-testlerna.0

package/dist/s3search/s3TableSchemas.js

@@ -0,0 +1,272 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rulesS3TableSql = exports.reconciliationReportsS3TableSql = exports.providersS3TableSql = exports.pdrsS3TableSql = exports.granulesExecutionsS3TableSql = exports.granulesS3TableSql = exports.filesS3TableSql = exports.executionsS3TableSql = exports.collectionsS3TableSql = exports.asyncOperationsS3TableSql = void 0;
+const asyncOperationsS3TableSql = (tableName = 'async_operations') => `
+  CREATE TABLE IF NOT EXISTS ${tableName} (
+    cumulus_id INTEGER PRIMARY KEY,
+    id UUID NOT NULL,
+    description TEXT NOT NULL,
+    operation_type TEXT NOT NULL,
+    output JSON,
+    status TEXT NOT NULL,
+    task_arn TEXT,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    CONSTRAINT async_operations_id_unique UNIQUE (id),
+    CONSTRAINT async_operations_status_check
+        CHECK (status IN (
+            'RUNNING',
+            'SUCCEEDED',
+            'RUNNER_FAILED',
+            'TASK_FAILED'
+        )),
+    CONSTRAINT async_operations_operation_type_check
+        CHECK (operation_type IN (
+            'Bulk Execution Archive',
+            'Bulk Execution Delete',
+            'Bulk Granules',
+            'Bulk Granule Archive',
+            'Bulk Granule Delete',
+            'Bulk Granule Reingest',
+            'Data Migration',
+            'Dead-Letter Processing',
+            'DLA Migration',
+            'ES Index',
+            'Kinesis Replay',
+            'Migration Count Report',
+            'Reconciliation Report',
+            'SQS Replay'
+        ))
+);`;
+exports.asyncOperationsS3TableSql = asyncOperationsS3TableSql;
+const collectionsS3TableSql = (tableName = 'collections') => `
+  CREATE TABLE IF NOT EXISTS ${tableName} (
+    cumulus_id INTEGER PRIMARY KEY,
+    name TEXT NOT NULL,
+    version TEXT NOT NULL,
+    sample_file_name TEXT NOT NULL,
+    granule_id_validation_regex TEXT NOT NULL,
+    granule_id_extraction_regex TEXT NOT NULL,
+    files JSON NOT NULL,
+    process TEXT,
+    url_path TEXT,
+    duplicate_handling TEXT,
+    report_to_ems BOOLEAN,
+    ignore_files_config_for_discovery BOOLEAN,
+    meta JSON,
+    tags JSON,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    UNIQUE (name, version),
+    CHECK (duplicate_handling IN ('error', 'replace', 'skip', 'version'))
+);`;
+exports.collectionsS3TableSql = collectionsS3TableSql;
+const executionsS3TableSql = (tableName = 'executions') => `
+  CREATE TABLE IF NOT EXISTS ${tableName} (
+    cumulus_id BIGINT PRIMARY KEY,
+    arn TEXT NOT NULL,
+    async_operation_cumulus_id INTEGER,
+    collection_cumulus_id INTEGER,
+    parent_cumulus_id BIGINT,
+    cumulus_version TEXT,
+    url TEXT,
+    status TEXT NOT NULL,
+    tasks JSON,
+    error JSON,
+    workflow_name TEXT,
+    duration REAL,
+    original_payload JSON,
+    final_payload JSON,
+    "timestamp" TIMESTAMPTZ,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    archived BOOLEAN NOT NULL DEFAULT FALSE,
+    CONSTRAINT executions_arn_unique UNIQUE (arn),
+    CONSTRAINT executions_url_unique UNIQUE (url),
+    CONSTRAINT executions_async_operation_cumulus_id_foreign
+        FOREIGN KEY (async_operation_cumulus_id)
+        REFERENCES async_operations (cumulus_id),
+    CONSTRAINT executions_collection_cumulus_id_foreign
+        FOREIGN KEY (collection_cumulus_id)
+        REFERENCES collections (cumulus_id),
+    CONSTRAINT executions_parent_cumulus_id_foreign
+        FOREIGN KEY (parent_cumulus_id)
+        REFERENCES ${tableName} (cumulus_id),
+    CONSTRAINT executions_status_check
+        CHECK (status IN ('running', 'completed', 'failed', 'unknown'))
+);`;
+exports.executionsS3TableSql = executionsS3TableSql;
+const filesS3TableSql = (tableName = 'files') => `
+  CREATE TABLE IF NOT EXISTS ${tableName} (
+    cumulus_id BIGINT PRIMARY KEY,
+    granule_cumulus_id BIGINT NOT NULL,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    file_size BIGINT,
+    bucket TEXT NOT NULL,
+    checksum_type TEXT,
+    checksum_value TEXT,
+    file_name TEXT,
+    key TEXT NOT NULL,
+    path TEXT,
+    source TEXT,
+    type TEXT,
+    CONSTRAINT files_bucket_key_unique UNIQUE (bucket, key),
+    CONSTRAINT files_granule_cumulus_id_foreign
+        FOREIGN KEY (granule_cumulus_id)
+        REFERENCES granules (cumulus_id)
+);`;
+exports.filesS3TableSql = filesS3TableSql;
+const granulesS3TableSql = (tableName = 'granules') => `
+  CREATE TABLE IF NOT EXISTS ${tableName} (
+    cumulus_id BIGINT PRIMARY KEY,
+    granule_id TEXT NOT NULL,
+    status TEXT NOT NULL,
+    collection_cumulus_id INTEGER NOT NULL,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    published BOOLEAN,
+    duration REAL,
+    time_to_archive REAL,
+    time_to_process REAL,
+    product_volume BIGINT,
+    error JSON,
+    cmr_link TEXT,
+    pdr_cumulus_id INTEGER,
+    provider_cumulus_id INTEGER,
+    beginning_date_time TIMESTAMPTZ,
+    ending_date_time TIMESTAMPTZ,
+    last_update_date_time TIMESTAMPTZ,
+    processing_end_date_time TIMESTAMPTZ,
+    processing_start_date_time TIMESTAMPTZ,
+    production_date_time TIMESTAMPTZ,
+    query_fields JSON,
+    "timestamp" TIMESTAMPTZ,
+    producer_granule_id TEXT NOT NULL,
+    archived BOOLEAN NOT NULL DEFAULT FALSE,
+    UNIQUE (collection_cumulus_id, granule_id),
+    CHECK (status IN ('running', 'completed', 'failed', 'queued'))
+);`;
+exports.granulesS3TableSql = granulesS3TableSql;
+const granulesExecutionsS3TableSql = (tableName = 'granules_executions') => `
+  CREATE TABLE IF NOT EXISTS ${tableName} (
+    granule_cumulus_id BIGINT NOT NULL,
+    execution_cumulus_id BIGINT NOT NULL,
+    CONSTRAINT granules_executions_granule_execution_unique
+        UNIQUE (granule_cumulus_id, execution_cumulus_id),
+    CONSTRAINT granules_executions_execution_cumulus_id_foreign
+        FOREIGN KEY (execution_cumulus_id)
+        REFERENCES executions (cumulus_id),
+    CONSTRAINT granules_executions_granule_cumulus_id_foreign
+        FOREIGN KEY (granule_cumulus_id)
+        REFERENCES granules (cumulus_id)
+);`;
+exports.granulesExecutionsS3TableSql = granulesExecutionsS3TableSql;
+const pdrsS3TableSql = (tableName = 'pdrs') => `
+  CREATE TABLE IF NOT EXISTS ${tableName} (
+    cumulus_id INTEGER PRIMARY KEY,
+    collection_cumulus_id INTEGER NOT NULL,
+    provider_cumulus_id INTEGER NOT NULL,
+    execution_cumulus_id BIGINT,
+    status TEXT NOT NULL,
+    name TEXT NOT NULL,
+    progress REAL,
+    pan_sent BOOLEAN,
+    pan_message TEXT,
+    stats JSON,
+    address TEXT,
+    original_url TEXT,
+    duration REAL,
+    "timestamp" TIMESTAMPTZ,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    CONSTRAINT pdrs_name_unique UNIQUE (name),
+    CONSTRAINT pdrs_collection_cumulus_id_foreign
+        FOREIGN KEY (collection_cumulus_id)
+        REFERENCES collections (cumulus_id),
+    CONSTRAINT pdrs_execution_cumulus_id_foreign
+        FOREIGN KEY (execution_cumulus_id)
+        REFERENCES executions (cumulus_id),
+    CONSTRAINT pdrs_provider_cumulus_id_foreign
+        FOREIGN KEY (provider_cumulus_id)
+        REFERENCES providers (cumulus_id),
+    CONSTRAINT pdrs_status_check
+        CHECK (status IN ('running', 'failed', 'completed'))
+);`;
+exports.pdrsS3TableSql = pdrsS3TableSql;
+const providersS3TableSql = (tableName = 'providers') => `
+  CREATE TABLE IF NOT EXISTS ${tableName} (
+    cumulus_id INTEGER PRIMARY KEY,
+    name TEXT NOT NULL,
+    protocol TEXT NOT NULL DEFAULT 'http',
+    host TEXT NOT NULL,
+    port INTEGER,
+    username TEXT,
+    password TEXT,
+    global_connection_limit INTEGER,
+    private_key TEXT,
+    cm_key_id TEXT,
+    certificate_uri TEXT,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    allowed_redirects TEXT[],
+    max_download_time INTEGER,
+    CONSTRAINT providers_name_unique UNIQUE (name),
+    CONSTRAINT providers_protocol_check
+        CHECK (protocol IN ('http', 'https', 'ftp', 'sftp', 's3'))
+);`;
+exports.providersS3TableSql = providersS3TableSql;
+const reconciliationReportsS3TableSql = (tableName = 'reconciliation_reports') => `
+  CREATE TABLE IF NOT EXISTS ${tableName} (
+    cumulus_id INTEGER PRIMARY KEY,
+    name TEXT NOT NULL,
+    type TEXT NOT NULL,
+    status TEXT NOT NULL,
+    location TEXT,
+    error JSON,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    CONSTRAINT reconciliation_reports_name_unique UNIQUE (name),
+    CONSTRAINT reconciliation_reports_type_check
+        CHECK (type IN (
+            'Granule Inventory',
+            'Granule Not Found',
+            'Internal',
+            'Inventory',
+            'ORCA Backup'
+        )),
+    CONSTRAINT reconciliation_reports_status_check
+        CHECK (status IN ('Generated', 'Pending', 'Failed'))
+);`;
+exports.reconciliationReportsS3TableSql = reconciliationReportsS3TableSql;
+const rulesS3TableSql = (tableName = 'rules') => `
+  CREATE TABLE IF NOT EXISTS ${tableName} (
+    cumulus_id INTEGER PRIMARY KEY,
+    name TEXT NOT NULL,
+    workflow TEXT NOT NULL,
+    collection_cumulus_id INTEGER,
+    provider_cumulus_id INTEGER,
+    type TEXT NOT NULL,
+    enabled BOOLEAN NOT NULL,
+    value TEXT,
+    arn TEXT,
+    log_event_arn TEXT,
+    execution_name_prefix TEXT,
+    payload JSON,
+    meta JSON,
+    tags JSON,
+    queue_url TEXT,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    CONSTRAINT rules_name_unique UNIQUE (name),
+    CONSTRAINT rules_collection_cumulus_id_foreign
+        FOREIGN KEY (collection_cumulus_id)
+        REFERENCES collections (cumulus_id),
+    CONSTRAINT rules_provider_cumulus_id_foreign
+        FOREIGN KEY (provider_cumulus_id)
+        REFERENCES providers (cumulus_id),
+    CONSTRAINT rules_type_check
+        CHECK (type IN ('onetime', 'scheduled', 'sns', 'kinesis', 'sqs'))
+);`;
+exports.rulesS3TableSql = rulesS3TableSql;
+//# sourceMappingURL=s3TableSchemas.js.map

package/dist/search/BaseSearch.d.ts

@@ -1,11 +1,44 @@
 import { Knex } from 'knex';
 import { BaseRecord } from '../types/base';
 import { DbQueryParameters, QueryEvent, QueryStringParameters } from '../types/search';
+export declare type Meta = {
+    name: string;
+    stack?: string;
+    table?: string;
+    limit?: number;
+    page?: number;
+    count?: number;
+};
 export declare const typeToTable: {
     [key: string]: string;
 };
 /**
- * Class to build and execute db search query
+ * BaseSearch
+ *
+ * Abstract base class for building and executing database search queries.
+ *
+ * Responsibilities:
+ *  - Parse and normalize incoming query string parameters.
+ *  - Build database queries using Knex.
+ *  - Execute queries against PostgreSQL by default.
+ *  - Return standardized search API response format including metadata.
+ *
+ * Default Behavior:
+ *  - The `query()` method executes against PostgreSQL using a Knex client.
+ *
+ * DuckDB Support:
+ *  - Subclasses that query DuckDB (e.g., *S3Search classes) must override
+ *    the `query()` and related methods
+ *  - DuckDB subclasses are responsible for:
+ *      - Executing queries using a DuckDB connection.
+ *      - Handling sequential execution (to avoid prepared statement conflicts).
+ *      - Translating DuckDB result types (e.g., string dates/JSON) into proper API types.
+ *
+ * Design Notes:
+ *  - Query construction logic (e.g., `buildSearch`) is shared across Postgres
+ *    and DuckDB implementations.
+ *  - Execution strategy is delegated to subclasses when a different database
+ *    engine is required.
  */
 declare abstract class BaseSearch {
     readonly type: string;
@@ -44,6 +77,17 @@ declare abstract class BaseSearch {
      * @returns whether an estimated row count should be returned
      */
     protected shouldEstimateRowcount(countSql: string): boolean;
+    /**
+     * Build a JSON query expression string for nested fields.
+     *
+     *
+     * @param fullFieldName - Dot-separated JSON path, e.g., 'query_fields.cnm.receivedTime'
+     * @returns The JSON query path string
+     * @example
+     * buildJsonQueryExpression('query_fields.cnm.receivedTime')
+     * // returns: query_fields -> 'cnm' ->> 'receivedTime'
+     */
+    protected buildJsonQueryExpression: (fullFieldName: string) => string;
     /**
      * Build the search query
      *
@@ -59,7 +103,7 @@ declare abstract class BaseSearch {
      *
      * @returns metadata template
      */
-    private _metaTemplate;
+    protected _metaTemplate(): Meta;
     /**
      * Build basic query
      *

package/dist/search/BaseSearch.js

@@ -22,12 +22,55 @@ exports.typeToTable = {
     reconciliationReport: tables_1.TableNames.reconciliationReports,
 };
 /**
- * Class to build and execute db search query
+ * BaseSearch
+ *
+ * Abstract base class for building and executing database search queries.
+ *
+ * Responsibilities:
+ *  - Parse and normalize incoming query string parameters.
+ *  - Build database queries using Knex.
+ *  - Execute queries against PostgreSQL by default.
+ *  - Return standardized search API response format including metadata.
+ *
+ * Default Behavior:
+ *  - The `query()` method executes against PostgreSQL using a Knex client.
+ *
+ * DuckDB Support:
+ *  - Subclasses that query DuckDB (e.g., *S3Search classes) must override
+ *    the `query()` and related methods
+ *  - DuckDB subclasses are responsible for:
+ *      - Executing queries using a DuckDB connection.
+ *      - Handling sequential execution (to avoid prepared statement conflicts).
+ *      - Translating DuckDB result types (e.g., string dates/JSON) into proper API types.
+ *
+ * Design Notes:
+ *  - Query construction logic (e.g., `buildSearch`) is shared across Postgres
+ *    and DuckDB implementations.
+ *  - Execution strategy is delegated to subclasses when a different database
+ *    engine is required.
  */
 class BaseSearch {
     constructor(event, type) {
         // parsed from queryStringParameters for query build
         this.dbQueryParameters = {};
+        /**
+         * Build a JSON query expression string for nested fields.
+         *
+         *
+         * @param fullFieldName - Dot-separated JSON path, e.g., 'query_fields.cnm.receivedTime'
+         * @returns The JSON query path string
+         * @example
+         * buildJsonQueryExpression('query_fields.cnm.receivedTime')
+         * // returns: query_fields -> 'cnm' ->> 'receivedTime'
+         */
+        this.buildJsonQueryExpression = (fullFieldName) => {
+            const normalizedFieldName = fullFieldName === 'error.Error.keyword'
+                ? 'error.Error' : fullFieldName;
+            const [column, ...pathParts] = normalizedFieldName.split('.');
+            return `${column}${pathParts
+                .map((p, i) => (i === pathParts.length - 1 ? ` ->> '${p}'` : ` -> '${p}'`))
+                .join('')}`;
+        };
         this.type = type;
         this.tableName = exports.typeToTable[this.type];
         this.queryStringParameters = event?.queryStringParameters ?? {};
@@ -81,7 +124,7 @@ class BaseSearch {
      * @returns whether an estimated row count should be returned
      */
     shouldEstimateRowcount(countSql) {
-        const isBasicQuery = (countSql === `select count(*) from "${this.tableName}"`);
+        const isBasicQuery = (countSql === `select count(* as count) from "${this.tableName}"`);
         return this.dbQueryParameters.estimateTableRowCount === true && isBasicQuery;
     }
     /**
@@ -127,7 +170,7 @@ class BaseSearch {
      */
     buildBasicQuery(knex) {
         const countQuery = knex(this.tableName)
-            .count('*');
+            .count('* as count');
         const searchQuery = knex(this.tableName)
             .select(`${this.tableName}.*`);
         return { countQuery, searchQuery };
@@ -158,6 +201,10 @@ class BaseSearch {
         Object.entries(exists).forEach(([name, value]) => {
             const queryMethod = value ? 'whereNotNull' : 'whereNull';
             const checkNull = value ? 'not null' : 'null';
+            if (name.includes('.')) {
+                [countQuery, searchQuery].forEach((query) => query?.whereRaw(`(${this.tableName}.${this.buildJsonQueryExpression(name)}) is ${checkNull}`));
+                return;
+            }
             switch (name) {
                 case 'collectionName':
                 case 'collectionVersion':
@@ -175,10 +222,6 @@ class BaseSearch {
                 case 'asyncOperationId':
                     [countQuery, searchQuery].forEach((query) => query?.[queryMethod](`${this.tableName}.async_operation_cumulus_id`));
                     break;
-                case 'error':
-                case 'error.Error':
-                    [countQuery, searchQuery].forEach((query) => query?.whereRaw(`${this.tableName}.error ->> 'Error' is ${checkNull}`));
-                    break;
                 case 'parentArn':
                     [countQuery, searchQuery].forEach((query) => query?.[queryMethod](`${this.tableName}.parent_cumulus_id`));
                     break;
@@ -200,8 +243,21 @@ class BaseSearch {
     buildRangeQuery(params) {
         const { countQuery, searchQuery, dbQueryParameters } = params;
         const { range = {} } = dbQueryParameters ?? this.dbQueryParameters;
+        const queries = [countQuery, searchQuery];
         Object.entries(range).forEach(([name, rangeValues]) => {
-            const { gte, lte } = rangeValues;
+            const { gte, lte } = rangeValues ?? {};
+            if (!gte && !lte)
+                return;
+            if (name.includes('.')) {
+                const jsonExpr = `(${this.tableName}.${this.buildJsonQueryExpression(name)})`;
+                if (gte) {
+                    queries.forEach((query) => query?.whereRaw(`${jsonExpr} >= ?`, [gte]));
+                }
+                if (lte) {
+                    queries.forEach((query) => query?.whereRaw(`${jsonExpr} <= ?`, [lte]));
+                }
+                return;
+            }
             if (gte) {
                 [countQuery, searchQuery].forEach((query) => query?.where(`${this.tableName}.${name}`, '>=', gte));
             }
@@ -223,6 +279,10 @@ class BaseSearch {
         const { countQuery, searchQuery, dbQueryParameters } = params;
         const { term = {} } = dbQueryParameters ?? this.dbQueryParameters;
         Object.entries(term).forEach(([name, value]) => {
+            if (name.includes('.')) {
+                [countQuery, searchQuery].forEach((query) => query?.whereRaw(`(${this.tableName}.${this.buildJsonQueryExpression(name)}) = ?`, value));
+                return;
+            }
             switch (name) {
                 case 'collectionName':
                     [countQuery, searchQuery].forEach((query) => query?.where(`${collectionsTable}.name`, value));
@@ -239,10 +299,6 @@ class BaseSearch {
                 case 'pdrName':
                     [countQuery, searchQuery].forEach((query) => query?.where(`${pdrsTable}.name`, value));
                     break;
-                case 'error.Error':
-                    [countQuery, searchQuery]
-                        .forEach((query) => value && query?.whereRaw(`${this.tableName}.error->>'Error' = ?`, value));
-                    break;
                 case 'asyncOperationId':
                     [countQuery, searchQuery].forEach((query) => query?.where(`${asyncOperationsTable}.id`, value));
                     break;
@@ -282,6 +338,10 @@ class BaseSearch {
                 .forEach((query) => query?.whereIn([`${collectionsTable}.name`, `${collectionsTable}.version`], collectionPair));
         }
         Object.entries((0, omit_1.default)(terms, ['collectionName', 'collectionVersion'])).forEach(([name, value]) => {
+            if (name.includes('.')) {
+                [countQuery, searchQuery].forEach((query) => query?.whereRaw(`(${this.tableName}.${this.buildJsonQueryExpression(name)}) in (${value.map(() => '?').join(',')})`, [...value]));
+                return;
+            }
             switch (name) {
                 case 'executionArn':
                     [countQuery, searchQuery].forEach((query) => query?.whereIn(`${executionsTable}.arn`, value));
@@ -292,10 +352,6 @@ class BaseSearch {
                 case 'pdrName':
                     [countQuery, searchQuery].forEach((query) => query?.whereIn(`${pdrsTable}.name`, value));
                     break;
-                case 'error.Error':
-                    [countQuery, searchQuery]
-                        .forEach((query) => query?.whereRaw(`${this.tableName}.error->>'Error' in (${value.map(() => '?').join(',')})`, [...value]));
-                    break;
                 case 'asyncOperationId':
                     [countQuery, searchQuery].forEach((query) => query?.whereIn(`${asyncOperationsTable}.id`, value));
                     break;
@@ -328,6 +384,10 @@ class BaseSearch {
             }));
         }
         Object.entries((0, omit_1.default)(term, ['collectionName', 'collectionVersion'])).forEach(([name, value]) => {
+            if (name.includes('.')) {
+                [countQuery, searchQuery].forEach((query) => query?.whereRaw(`(${this.tableName}.${this.buildJsonQueryExpression(name)}) != ?`, value));
+                return;
+            }
             switch (name) {
                 case 'executionArn':
                     [countQuery, searchQuery].forEach((query) => query?.whereNot(`${executionsTable}.arn`, value));
@@ -344,9 +404,6 @@ class BaseSearch {
                 case 'parentArn':
                     [countQuery, searchQuery].forEach((query) => query?.whereNot(`${executionsTable}_parent.arn`, value));
                     break;
-                case 'error.Error':
-                    [countQuery, searchQuery].forEach((query) => value && query?.whereRaw(`${this.tableName}.error->>'Error' != ?`, value));
-                    break;
                 default:
                     [countQuery, searchQuery].forEach((query) => query?.whereNot(`${this.tableName}.${name}`, value));
                     break;
@@ -361,18 +418,23 @@ class BaseSearch {
      * @param [params.dbQueryParameters] - db query parameters
      */
     buildSortQuery(params) {
+        const customColumns = ['collectionName', 'collectionVersion', 'executionArn', 'providerName', 'pdrName', 'asyncOperationId', 'parentArn'];
         const { searchQuery, dbQueryParameters } = params;
         const { sort } = dbQueryParameters || this.dbQueryParameters;
         sort?.forEach((key) => {
-            if (key.column.startsWith('error')) {
-                searchQuery.orderByRaw(`${this.tableName}.error ->> 'Error' ${key.order}`);
+            const prefixedColumn = `${this.tableName}.${key.column}`;
+            if (key.column.includes('.')) {
+                searchQuery.orderByRaw(`(${this.tableName}.${this.buildJsonQueryExpression(key.column)}) ${key.order}`);
             }
             else if (dbQueryParameters?.collate) {
                 searchQuery.orderByRaw(`${key} collate \"${dbQueryParameters.collate}\"`);
             }
-            else {
+            else if (customColumns.includes(key.column)) {
                 searchQuery.orderBy([key]);
             }
+            else {
+                searchQuery.orderBy(prefixedColumn, key.order);
+            }
         });
     }
     /**

package/dist/search/CollectionSearch.d.ts

@@ -3,14 +3,17 @@ import { CollectionRecord } from '@cumulus/types/api/collections';
 import { BaseSearch } from './BaseSearch';
 import { DbQueryParameters, QueryEvent } from '../types/search';
 import { PostgresCollectionRecord } from '../types/collection';
-declare type Statuses = {
+export declare type Statuses = {
     queued: number;
     completed: number;
     failed: number;
     running: number;
     total: number;
 };
-interface CollectionRecordApi extends CollectionRecord {
+export declare type StatsRecords = {
+    [key: number]: Statuses;
+};
+export interface CollectionRecordApi extends CollectionRecord {
     stats?: Statuses;
 }
 /**
@@ -58,7 +61,7 @@ export declare class CollectionSearch extends BaseSearch {
      * @param knex - knex for the stats query
      * @returns the collection's granules status' aggregation
      */
-    private retrieveGranuleStats;
+    protected retrieveGranuleStats(collectionCumulusIds: number[], knex: Knex): Promise<StatsRecords>;
     /**
      * Translate postgres records to api records
      *
@@ -68,5 +71,4 @@ export declare class CollectionSearch extends BaseSearch {
      */
     protected translatePostgresRecordsToApiRecords(pgRecords: PostgresCollectionRecord[], knex: Knex): Promise<Partial<CollectionRecordApi>[]>;
 }
-export {};
 //# sourceMappingURL=CollectionSearch.d.ts.map

package/dist/search/CollectionSearch.js

@@ -61,8 +61,7 @@ class CollectionSearch extends BaseSearch_1.BaseSearch {
         subQuery
             .clear('select')
             .select(1)
-            .where(`${granulesTable}.collection_cumulus_id`, knex.raw(`${this.tableName}.cumulus_id`))
-            .limit(1);
+            .where(`${granulesTable}.collection_cumulus_id`, knex.raw(`${this.tableName}.cumulus_id`));
         return subQuery;
     }
     /**
@@ -101,7 +100,7 @@ class CollectionSearch extends BaseSearch_1.BaseSearch {
         }
         statsQuery
             .select(`${granulesTable}.collection_cumulus_id`, `${granulesTable}.status`)
-            .count('*')
+            .count('* as count')
             .groupBy(`${granulesTable}.collection_cumulus_id`, `${granulesTable}.status`)
             .whereIn(`${granulesTable}.collection_cumulus_id`, collectionCumulusIds);
         log.debug(`retrieveGranuleStats statsQuery: ${statsQuery?.toSQL().sql}`);

package/dist/search/ExecutionSearch.d.ts

@@ -14,7 +14,7 @@ interface ExecutionRecord extends BaseRecord, PostgresExecutionRecord {
  * Class to build and execute db search query for executions
  */
 export declare class ExecutionSearch extends BaseSearch {
-    constructor(event: QueryEvent);
+    constructor(event: QueryEvent, enableEstimate?: boolean);
     /**
      * check if joined async_operations table search is needed
      *

package/dist/search/ExecutionSearch.js

@@ -16,9 +16,9 @@ const log = new logger_1.default({ sender: '@cumulus/db/ExecutionSearch' });
  * Class to build and execute db search query for executions
  */
 class ExecutionSearch 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, 'execution');
@@ -62,7 +62,7 @@ class ExecutionSearch extends BaseSearch_1.BaseSearch {
             searchQuery.select({ parentArn: `${executionsTable}_parent.arn` });
         }
         const countQuery = knex(this.tableName)
-            .count('*');
+            .count('* as count');
         if (this.searchCollection()) {
             countQuery.innerJoin(collectionsTable, `${this.tableName}.collection_cumulus_id`, `${collectionsTable}.cumulus_id`);
             searchQuery.innerJoin(collectionsTable, `${this.tableName}.collection_cumulus_id`, `${collectionsTable}.cumulus_id`);

package/dist/search/GranuleSearch.d.ts

@@ -4,7 +4,7 @@ import { BaseRecord } from '../types/base';
 import { BaseSearch } from './BaseSearch';
 import { DbQueryParameters, QueryEvent } from '../types/search';
 import { PostgresGranuleRecord } from '../types/granule';
-interface GranuleRecord extends BaseRecord, PostgresGranuleRecord {
+export interface GranuleRecord extends BaseRecord, PostgresGranuleRecord {
     collectionName: string;
     collectionVersion: string;
     pdrName?: string;
@@ -14,7 +14,7 @@ interface GranuleRecord extends BaseRecord, PostgresGranuleRecord {
  * Class to build and execute db search query for granules
  */
 export declare class GranuleSearch extends BaseSearch {
-    constructor(event: QueryEvent);
+    constructor(event: QueryEvent, enableEstimate?: boolean);
     /**
      * Build basic query
      *
@@ -59,5 +59,4 @@ export declare class GranuleSearch extends BaseSearch {
      */
     protected translatePostgresRecordsToApiRecords(pgRecords: GranuleRecord[], knex: Knex): Promise<Partial<ApiGranuleRecord>[]>;
 }
-export {};
 //# sourceMappingURL=GranuleSearch.d.ts.map