@cumulus/db 21.3.1-alpha.0 → 21.3.2-testlerna.0

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

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