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

package/dist/index.d.ts

@@ -41,6 +41,7 @@ export { ProviderSearch, } from './search/ProviderSearch';
 export { RuleSearch, } from './search/RuleSearch';
 export { StatsSearch, } from './search/StatsSearch';
 export { ReconciliationReportSearch, } from './search/ReconciliationReportSearch';
+export { CollectionS3Search, } from './s3search/CollectionS3Search';
 export { AsyncOperationPgModel } from './models/async_operation';
 export { BasePgModel } from './models/base';
 export { CollectionPgModel } from './models/collection';

package/dist/index.js

@@ -24,7 +24,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getApiExecutionCumulusIds = exports.executionArnsFromGranuleIdsAndWorkflowNames = exports.batchDeleteExecutionFromDatabaseByCumulusCollectionId = exports.getUniqueCollectionsByGranuleFilter = exports.getCollectionsByGranuleIds = exports.translatePostgresReconReportToApiReconReport = exports.translateApiReconReportToPostgresReconReport = exports.translatePostgresPdrToApiPdr = exports.translateApiPdrToPostgresPdr = exports.translatePostgresGranuleResultToApiGranule = exports.translatePostgresGranuleToApiGranule = exports.translateApiGranuleToPostgresGranuleWithoutNilsRemoved = exports.translateApiGranuleToPostgresGranule = exports.translatePostgresExecutionToApiExecution = exports.translateApiExecutionToPostgresExecutionWithoutNilsRemoved = exports.translateApiExecutionToPostgresExecution = exports.translateApiRuleToPostgresRuleRaw = exports.translateApiRuleToPostgresRule = exports.translatePostgresRuleToApiRule = exports.translatePostgresProviderToApiProvider = exports.translateApiProviderToPostgresProvider = exports.translatePostgresCollectionToApiCollection = exports.translateApiCollectionToPostgresCollection = exports.translatePostgresFileToApiFile = exports.translateApiFiletoPostgresFile = exports.translatePostgresAsyncOperationToApiAsyncOperation = exports.translateApiAsyncOperationToPostgresAsyncOperation = exports.nullifyUndefinedProviderValues = exports.validateProviderHost = exports.migrationDir = exports.TableNames = exports.createRejectableTransaction = exports.localStackConnectionEnv = exports.getKnexConfig = exports.getKnexClient = exports.isCollisionError = exports.generateLocalTestDb = exports.fakeRuleRecordFactory = exports.fakeReconciliationReportRecordFactory = exports.fakeProviderRecordFactory = exports.fakePdrRecordFactory = exports.fakeGranuleRecordFactory = exports.fakeFileRecordFactory = exports.fakeExecutionRecordFactory = exports.fakeCollectionRecordFactory = exports.fakeAsyncOperationRecordFactory = exports.destroyLocalTestDb = exports.deleteTestDatabase = exports.createTestDatabase = exports.Knex = void 0;
-exports.RulePgModel = exports.ReconciliationReportPgModel = exports.ProviderPgModel = exports.PdrPgModel = exports.GranulesExecutionsPgModel = exports.GranulePgModel = exports.FilePgModel = exports.ExecutionPgModel = exports.CollectionPgModel = exports.BasePgModel = exports.AsyncOperationPgModel = exports.ReconciliationReportSearch = exports.StatsSearch = exports.RuleSearch = exports.ProviderSearch = exports.PdrSearch = exports.GranuleSearch = exports.ExecutionSearch = exports.CollectionSearch = exports.AsyncOperationSearch = exports.QuerySearchClient = exports.updateBatchGranulesCollection = exports.getGranuleAndCollection = exports.getGranulesByGranuleId = exports.getGranulesByApiPropertiesQuery = exports.upsertGranuleWithExecutionJoinRecord = exports.getGranuleCollectionId = exports.getApiGranuleExecutionCumulusIds = exports.getApiGranuleCumulusIds = exports.getGranuleIdAndCollectionIdFromFile = exports.getFilesAndGranuleInfoQuery = exports.newestExecutionArnFromGranuleIdWorkflowName = exports.getWorkflowNameIntersectFromGranuleIds = exports.getExecutionInfoByGranuleCumulusId = exports.getApiGranuleExecutionCumulusIdsByExecution = void 0;
+exports.RulePgModel = exports.ReconciliationReportPgModel = exports.ProviderPgModel = exports.PdrPgModel = exports.GranulesExecutionsPgModel = exports.GranulePgModel = exports.FilePgModel = exports.ExecutionPgModel = exports.CollectionPgModel = exports.BasePgModel = exports.AsyncOperationPgModel = exports.CollectionS3Search = exports.ReconciliationReportSearch = exports.StatsSearch = exports.RuleSearch = exports.ProviderSearch = exports.PdrSearch = exports.GranuleSearch = exports.ExecutionSearch = exports.CollectionSearch = exports.AsyncOperationSearch = exports.QuerySearchClient = exports.updateBatchGranulesCollection = exports.getGranuleAndCollection = exports.getGranulesByGranuleId = exports.getGranulesByApiPropertiesQuery = exports.upsertGranuleWithExecutionJoinRecord = exports.getGranuleCollectionId = exports.getApiGranuleExecutionCumulusIds = exports.getApiGranuleCumulusIds = exports.getGranuleIdAndCollectionIdFromFile = exports.getFilesAndGranuleInfoQuery = exports.newestExecutionArnFromGranuleIdWorkflowName = exports.getWorkflowNameIntersectFromGranuleIds = exports.getExecutionInfoByGranuleCumulusId = exports.getApiGranuleExecutionCumulusIdsByExecution = void 0;
 const path = __importStar(require("path"));
 var knex_1 = require("knex");
 Object.defineProperty(exports, "Knex", { enumerable: true, get: function () { return knex_1.Knex; } });
@@ -131,6 +131,8 @@ var StatsSearch_1 = require("./search/StatsSearch");
 Object.defineProperty(exports, "StatsSearch", { enumerable: true, get: function () { return StatsSearch_1.StatsSearch; } });
 var ReconciliationReportSearch_1 = require("./search/ReconciliationReportSearch");
 Object.defineProperty(exports, "ReconciliationReportSearch", { enumerable: true, get: function () { return ReconciliationReportSearch_1.ReconciliationReportSearch; } });
+var CollectionS3Search_1 = require("./s3search/CollectionS3Search");
+Object.defineProperty(exports, "CollectionS3Search", { enumerable: true, get: function () { return CollectionS3Search_1.CollectionS3Search; } });
 var async_operation_1 = require("./models/async_operation");
 Object.defineProperty(exports, "AsyncOperationPgModel", { enumerable: true, get: function () { return async_operation_1.AsyncOperationPgModel; } });
 var base_1 = require("./models/base");

package/dist/s3search/AsyncOperationS3Search.d.ts

@@ -0,0 +1,20 @@
+import { DuckDBConnection } from '@duckdb/node-api';
+import { AsyncOperationSearch } from '../search/AsyncOperationSearch';
+import { QueryEvent } from '../types/search';
+/**
+ * Class to build and execute DuckDB search query for asyncOperation
+ */
+export declare class AsyncOperationS3Search extends AsyncOperationSearch {
+    private duckDBSearchExecutor;
+    constructor(event: QueryEvent, dbConnection: DuckDBConnection);
+    /**
+     * Build and execute search query
+     *
+     * @returns search result
+     */
+    query(): Promise<{
+        meta: import("../search/BaseSearch").Meta;
+        results: any[];
+    }>;
+}
+//# sourceMappingURL=AsyncOperationS3Search.d.ts.map

package/dist/s3search/AsyncOperationS3Search.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncOperationS3Search = void 0;
+const DuckDBSearchExecutor_1 = require("./DuckDBSearchExecutor");
+const AsyncOperationSearch_1 = require("../search/AsyncOperationSearch");
+/**
+ * Class to build and execute DuckDB search query for asyncOperation
+ */
+class AsyncOperationS3Search extends AsyncOperationSearch_1.AsyncOperationSearch {
+    constructor(event, dbConnection) {
+        super(event);
+        this.duckDBSearchExecutor = new DuckDBSearchExecutor_1.DuckDBSearchExecutor({
+            dbConnection,
+            dbQueryParameters: this.dbQueryParameters,
+            getMetaTemplate: this._metaTemplate.bind(this),
+            translateRecords: this.translatePostgresRecordsToApiRecords.bind(this),
+        });
+    }
+    /**
+     * Build and execute search query
+     *
+     * @returns search result
+     */
+    async query() {
+        return this.duckDBSearchExecutor.query((knexBuilder) => this.buildSearch(knexBuilder));
+    }
+}
+exports.AsyncOperationS3Search = AsyncOperationS3Search;
+//# sourceMappingURL=AsyncOperationS3Search.js.map

package/dist/s3search/CollectionS3Search.d.ts

@@ -0,0 +1,39 @@
+import { Knex } from 'knex';
+import { DuckDBConnection } from '@duckdb/node-api';
+import { CollectionSearch, StatsRecords, CollectionRecordApi } from '../search/CollectionSearch';
+import { PostgresCollectionRecord } from '../types/collection';
+import { QueryEvent } from '../types/search';
+/**
+ * Class to build and execute DuckDB search query for collections
+ */
+export declare class CollectionS3Search extends CollectionSearch {
+    private dbConnection;
+    private duckDBSearchExecutor;
+    constructor(event: QueryEvent, dbConnection: DuckDBConnection);
+    /**
+     * Executes stats query to get granules' status aggregation
+     *
+     * @param collectionCumulusIds - array of cumulusIds of the collections
+     * @param knexClient - knex for the stats query
+     * @returns the collection's granules status' aggregation
+     */
+    protected retrieveGranuleStats(collectionCumulusIds: number[], knexClient: Knex): Promise<StatsRecords>;
+    /**
+     * Translate postgres records to api records
+     *
+     * @param pgRecords - postgres Collection records returned from query
+     * @param knexClient - knex for the stats query if incldueStats is true
+     * @returns translated api records
+     */
+    protected translatePostgresRecordsToApiRecords(pgRecords: PostgresCollectionRecord[], knexClient: Knex): Promise<Partial<CollectionRecordApi>[]>;
+    /**
+     * Build and execute search query
+     *
+     * @returns search result
+     */
+    query(): Promise<{
+        meta: import("../search/BaseSearch").Meta;
+        results: any[];
+    }>;
+}
+//# sourceMappingURL=CollectionS3Search.d.ts.map

package/dist/s3search/CollectionS3Search.js

@@ -0,0 +1,113 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CollectionS3Search = void 0;
+const pick_1 = __importDefault(require("lodash/pick"));
+const logger_1 = __importDefault(require("@cumulus/logger"));
+const CollectionSearch_1 = require("../search/CollectionSearch");
+const tables_1 = require("../tables");
+const collections_1 = require("../translate/collections");
+const duckdbHelpers_1 = require("./duckdbHelpers");
+const GranuleS3Search_1 = require("./GranuleS3Search");
+const DuckDBSearchExecutor_1 = require("./DuckDBSearchExecutor");
+const log = new logger_1.default({ sender: '@cumulus/db/CollectionS3Search' });
+/**
+ * Class to build and execute DuckDB search query for collections
+ */
+class CollectionS3Search extends CollectionSearch_1.CollectionSearch {
+    constructor(event, dbConnection) {
+        super(event);
+        this.dbConnection = dbConnection;
+        this.duckDBSearchExecutor = new DuckDBSearchExecutor_1.DuckDBSearchExecutor({
+            dbConnection,
+            dbQueryParameters: this.dbQueryParameters,
+            getMetaTemplate: this._metaTemplate.bind(this),
+            translateRecords: this.translatePostgresRecordsToApiRecords.bind(this),
+        });
+    }
+    /**
+     * Executes stats query to get granules' status aggregation
+     *
+     * @param collectionCumulusIds - array of cumulusIds of the collections
+     * @param knexClient - knex for the stats query
+     * @returns the collection's granules status' aggregation
+     */
+    async retrieveGranuleStats(collectionCumulusIds, knexClient) {
+        const granulesTable = tables_1.TableNames.granules;
+        let statsQuery = knexClient(granulesTable);
+        if (this.active) {
+            const granuleS3Search = new GranuleS3Search_1.GranuleS3Search({ queryStringParameters: this.queryStringParameters }, this.dbConnection);
+            const { countQuery } = granuleS3Search.buildSearchForActiveCollections(knexClient);
+            statsQuery = countQuery.clear('select');
+        }
+        statsQuery
+            .select(`${granulesTable}.collection_cumulus_id`, `${granulesTable}.status`)
+            .count('* as count')
+            .groupBy(`${granulesTable}.collection_cumulus_id`, `${granulesTable}.status`)
+            .whereIn(`${granulesTable}.collection_cumulus_id`, collectionCumulusIds);
+        log.debug(`retrieveGranuleStats statsQuery: ${statsQuery?.toSQL().sql}`);
+        const { sql, bindings } = statsQuery.toSQL().toNative();
+        const reader = await this.dbConnection.runAndReadAll(sql, (0, duckdbHelpers_1.prepareBindings)(bindings));
+        const results = reader.getRowObjectsJson();
+        const reduced = results.reduce((acc, record) => {
+            const cumulusId = Number(record.collection_cumulus_id);
+            if (!acc[cumulusId]) {
+                acc[cumulusId] = {
+                    queued: 0,
+                    completed: 0,
+                    failed: 0,
+                    running: 0,
+                    total: 0,
+                };
+            }
+            acc[cumulusId][record.status] += Number(record.count);
+            acc[cumulusId]['total'] += Number(record.count);
+            return acc;
+        }, {});
+        return reduced;
+    }
+    /**
+     * Translate postgres records to api records
+     *
+     * @param pgRecords - postgres Collection records returned from query
+     * @param knexClient - knex for the stats query if incldueStats is true
+     * @returns translated api records
+     */
+    async translatePostgresRecordsToApiRecords(pgRecords, knexClient) {
+        log.debug(`translatePostgresRecordsToApiRecords number of records ${pgRecords.length} `);
+        const { fields } = this.dbQueryParameters;
+        let statsRecords;
+        const cumulusIds = pgRecords.map((record) => record.cumulus_id);
+        if (this.includeStats) {
+            statsRecords = await this.retrieveGranuleStats(cumulusIds, knexClient);
+        }
+        const apiRecords = pgRecords.map((record) => {
+            const apiRecord = (0, collections_1.translatePostgresCollectionToApiCollection)(record);
+            const apiRecordFinal = fields ? (0, pick_1.default)(apiRecord, fields) : apiRecord;
+            if (statsRecords) {
+                apiRecordFinal.stats = statsRecords[record.cumulus_id] ? statsRecords[record.cumulus_id]
+                    : {
+                        queued: 0,
+                        completed: 0,
+                        failed: 0,
+                        running: 0,
+                        total: 0,
+                    };
+            }
+            return apiRecordFinal;
+        });
+        return apiRecords;
+    }
+    /**
+     * Build and execute search query
+     *
+     * @returns search result
+     */
+    async query() {
+        return this.duckDBSearchExecutor.query((knexBuilder) => this.buildSearch(knexBuilder));
+    }
+}
+exports.CollectionS3Search = CollectionS3Search;
+//# sourceMappingURL=CollectionS3Search.js.map

package/dist/s3search/DuckDBSearchExecutor.d.ts

@@ -0,0 +1,36 @@
+import { Knex } from 'knex';
+import { DuckDBConnection } from '@duckdb/node-api';
+import { Meta } from '../search/BaseSearch';
+import { DbQueryParameters } from '../types/search';
+/**
+ * DuckDBSearchExecutor is a helper class for executing search queries on DuckDB.
+ * It wraps a DuckDB connection and provides a unified method to:
+ *   - Build queries using Knex (Postgres dialect)
+ *   - Execute them sequentially to avoid prepared statement conflicts
+ *   - Transform raw database records into API-ready records
+ *
+ * This class is intended to be used by S3Search subclasses that inherit
+ * from BaseSearch, allowing them to reuse query logic while providing
+ * custom record translation.
+ */
+export declare class DuckDBSearchExecutor {
+    private dbConnection;
+    private knexBuilder;
+    private dbQueryParameters;
+    private getMetaTemplate;
+    private translateRecords;
+    constructor(params: {
+        dbConnection: DuckDBConnection;
+        dbQueryParameters: DbQueryParameters;
+        getMetaTemplate: () => Meta;
+        translateRecords: (records: any[], knexClient: Knex) => any[] | Promise<any[]>;
+    });
+    query(buildSearch: (knex: Knex) => {
+        countQuery?: Knex.QueryBuilder;
+        searchQuery: Knex.QueryBuilder;
+    }): Promise<{
+        meta: Meta;
+        results: any[];
+    }>;
+}
+//# sourceMappingURL=DuckDBSearchExecutor.d.ts.map

package/dist/s3search/DuckDBSearchExecutor.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBSearchExecutor = void 0;
+const knex_1 = require("knex");
+const duckdbHelpers_1 = require("./duckdbHelpers");
+/**
+ * DuckDBSearchExecutor is a helper class for executing search queries on DuckDB.
+ * It wraps a DuckDB connection and provides a unified method to:
+ *   - Build queries using Knex (Postgres dialect)
+ *   - Execute them sequentially to avoid prepared statement conflicts
+ *   - Transform raw database records into API-ready records
+ *
+ * This class is intended to be used by S3Search subclasses that inherit
+ * from BaseSearch, allowing them to reuse query logic while providing
+ * custom record translation.
+ */
+class DuckDBSearchExecutor {
+    constructor(params) {
+        this.dbConnection = params.dbConnection;
+        this.dbQueryParameters = params.dbQueryParameters;
+        this.getMetaTemplate = params.getMetaTemplate;
+        this.translateRecords = params.translateRecords;
+        // Use pg dialect to generate DuckDB-compatible SQL ($1, $2, etc.)
+        this.knexBuilder = (0, knex_1.knex)({ client: 'pg' });
+    }
+    async query(buildSearch) {
+        const { countQuery, searchQuery } = buildSearch(this.knexBuilder);
+        const shouldReturnCountOnly = this.dbQueryParameters.countOnly === true;
+        const queryConfigs = shouldReturnCountOnly
+            ? [{ key: 'count', query: countQuery }]
+            : [
+                { key: 'count', query: countQuery },
+                { key: 'records', query: searchQuery },
+            ];
+        let countResult = [];
+        let records = [];
+        // sequential execution (DuckDB cannot handle multiple prepared statements simultaneously)
+        for (const config of queryConfigs.filter((c) => c.query)) {
+            const { sql, bindings } = config.query.clone().toSQL().toNative();
+            // eslint-disable-next-line no-await-in-loop
+            const reader = await this.dbConnection.runAndReadAll(sql, (0, duckdbHelpers_1.prepareBindings)(bindings));
+            const result = reader.getRowObjectsJson();
+            if (config.key === 'count')
+                countResult = result;
+            else
+                records = result;
+        }
+        const meta = this.getMetaTemplate();
+        meta.limit = this.dbQueryParameters.limit;
+        meta.page = this.dbQueryParameters.page;
+        meta.count = Number(countResult[0]?.count ?? 0);
+        const apiRecords = await this.translateRecords(records, this.knexBuilder);
+        return { meta, results: apiRecords };
+    }
+}
+exports.DuckDBSearchExecutor = DuckDBSearchExecutor;
+//# sourceMappingURL=DuckDBSearchExecutor.js.map

package/dist/s3search/ExecutionS3Search.d.ts

@@ -0,0 +1,20 @@
+import { DuckDBConnection } from '@duckdb/node-api';
+import { ExecutionSearch } from '../search/ExecutionSearch';
+import { QueryEvent } from '../types/search';
+/**
+ * Class to build and execute DuckDB search query for executions
+ */
+export declare class ExecutionS3Search extends ExecutionSearch {
+    private duckDBSearchExecutor;
+    constructor(event: QueryEvent, dbConnection: DuckDBConnection);
+    /**
+     * Build and execute search query
+     *
+     * @returns search result
+     */
+    query(): Promise<{
+        meta: import("../search/BaseSearch").Meta;
+        results: any[];
+    }>;
+}
+//# sourceMappingURL=ExecutionS3Search.d.ts.map

package/dist/s3search/ExecutionS3Search.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExecutionS3Search = void 0;
+const DuckDBSearchExecutor_1 = require("./DuckDBSearchExecutor");
+const ExecutionSearch_1 = require("../search/ExecutionSearch");
+/**
+ * Class to build and execute DuckDB search query for executions
+ */
+class ExecutionS3Search extends ExecutionSearch_1.ExecutionSearch {
+    constructor(event, dbConnection) {
+        super(event, false); // disables estimateTableRowCount
+        this.duckDBSearchExecutor = new DuckDBSearchExecutor_1.DuckDBSearchExecutor({
+            dbConnection,
+            dbQueryParameters: this.dbQueryParameters,
+            getMetaTemplate: this._metaTemplate.bind(this),
+            translateRecords: this.translatePostgresRecordsToApiRecords.bind(this),
+        });
+    }
+    /**
+     * Build and execute search query
+     *
+     * @returns search result
+     */
+    async query() {
+        return this.duckDBSearchExecutor.query((knexBuilder) => this.buildSearch(knexBuilder));
+    }
+}
+exports.ExecutionS3Search = ExecutionS3Search;
+//# sourceMappingURL=ExecutionS3Search.js.map

package/dist/s3search/GranuleS3Search.d.ts

@@ -0,0 +1,31 @@
+import { Knex } from 'knex';
+import { DuckDBConnection } from '@duckdb/node-api';
+import { ApiGranuleRecord } from '@cumulus/types/api/granules';
+import { GranuleRecord, GranuleSearch } from '../search/GranuleSearch';
+import { QueryEvent } from '../types/search';
+/**
+ * Class to build and execute DuckDB search query for granules
+ */
+export declare class GranuleS3Search extends GranuleSearch {
+    private dbConnection;
+    private duckDBSearchExecutor;
+    constructor(event: QueryEvent, dbConnection: DuckDBConnection);
+    /**
+     * Translate postgres records to api records
+     *
+     * @param pgRecords - postgres records returned from query
+     * @param knexClient - DB client
+     * @returns translated api records
+     */
+    protected translatePostgresRecordsToApiRecords(pgRecords: GranuleRecord[], knexClient: Knex): Promise<Partial<ApiGranuleRecord>[]>;
+    /**
+     * Build and execute search query
+     *
+     * @returns search result
+     */
+    query(): Promise<{
+        meta: import("../search/BaseSearch").Meta;
+        results: any[];
+    }>;
+}
+//# sourceMappingURL=GranuleS3Search.d.ts.map

package/dist/s3search/GranuleS3Search.js

@@ -0,0 +1,100 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GranuleS3Search = void 0;
+const pick_1 = __importDefault(require("lodash/pick"));
+const logger_1 = __importDefault(require("@cumulus/logger"));
+const duckdbHelpers_1 = require("./duckdbHelpers");
+const DuckDBSearchExecutor_1 = require("./DuckDBSearchExecutor");
+const GranuleSearch_1 = require("../search/GranuleSearch");
+const granules_1 = require("../translate/granules");
+const log = new logger_1.default({ sender: '@cumulus/db/GranuleS3Search' });
+/**
+ * Class to build and execute DuckDB search query for granules
+ */
+class GranuleS3Search extends GranuleSearch_1.GranuleSearch {
+    constructor(event, dbConnection) {
+        super(event, false); // disables estimateTableRowCount
+        this.dbConnection = dbConnection;
+        this.duckDBSearchExecutor = new DuckDBSearchExecutor_1.DuckDBSearchExecutor({
+            dbConnection,
+            dbQueryParameters: this.dbQueryParameters,
+            getMetaTemplate: this._metaTemplate.bind(this),
+            translateRecords: this.translatePostgresRecordsToApiRecords.bind(this),
+        });
+    }
+    /**
+     * Translate postgres records to api records
+     *
+     * @param pgRecords - postgres records returned from query
+     * @param knexClient - DB client
+     * @returns translated api records
+     */
+    async translatePostgresRecordsToApiRecords(pgRecords, knexClient) {
+        log.debug(`translatePostgresRecordsToApiRecords number of records ${pgRecords.length} `);
+        const { fields, includeFullRecord } = this.dbQueryParameters;
+        const fileMapping = {};
+        const executionMapping = {};
+        const cumulusIds = pgRecords.map((record) => record.cumulus_id);
+        if (includeFullRecord) {
+            //get files
+            const files = await (0, duckdbHelpers_1.getFilesByGranuleCumulusIds)({
+                connection: this.dbConnection,
+                granuleCumulusIds: cumulusIds,
+                knexBuilder: knexClient,
+            });
+            files.forEach((file) => {
+                if (!(file.granule_cumulus_id in fileMapping)) {
+                    fileMapping[file.granule_cumulus_id] = [];
+                }
+                fileMapping[file.granule_cumulus_id].push(file);
+            });
+            //get Executions
+            const executions = await (0, duckdbHelpers_1.getExecutionInfoByGranuleCumulusIds)({
+                connection: this.dbConnection,
+                granuleCumulusIds: cumulusIds,
+                knexBuilder: knexClient,
+            });
+            executions.forEach((execution) => {
+                if (!(execution.granule_cumulus_id in executionMapping)) {
+                    executionMapping[execution.granule_cumulus_id] = execution;
+                }
+            });
+        }
+        const apiRecords = pgRecords.map((item) => {
+            const collectionPgRecord = {
+                cumulus_id: item.collection_cumulus_id,
+                name: item.collectionName,
+                version: item.collectionVersion,
+            };
+            const executionUrls = executionMapping[item.cumulus_id]?.url
+                ? [{ url: executionMapping[item.cumulus_id].url }]
+                : [];
+            const pdr = item.pdrName ? { name: item.pdrName } : undefined;
+            const providerPgRecord = item.providerName ? { name: item.providerName } : undefined;
+            const fileRecords = fileMapping[item.cumulus_id] || [];
+            const apiRecord = (0, granules_1.translatePostgresGranuleToApiGranuleWithoutDbQuery)({
+                granulePgRecord: item,
+                collectionPgRecord,
+                pdr,
+                providerPgRecord,
+                files: fileRecords,
+                executionUrls,
+            });
+            return fields ? (0, pick_1.default)(apiRecord, fields) : apiRecord;
+        });
+        return apiRecords;
+    }
+    /**
+     * Build and execute search query
+     *
+     * @returns search result
+     */
+    async query() {
+        return this.duckDBSearchExecutor.query((knexBuilder) => this.buildSearch(knexBuilder));
+    }
+}
+exports.GranuleS3Search = GranuleS3Search;
+//# sourceMappingURL=GranuleS3Search.js.map

package/dist/s3search/PdrS3Search.d.ts

@@ -0,0 +1,20 @@
+import { DuckDBConnection } from '@duckdb/node-api';
+import { PdrSearch } from '../search/PdrSearch';
+import { QueryEvent } from '../types/search';
+/**
+ * Class to build and execute DuckDB search query for PDRs
+ */
+export declare class PdrS3Search extends PdrSearch {
+    private duckDBSearchExecutor;
+    constructor(event: QueryEvent, dbConnection: DuckDBConnection);
+    /**
+     * Build and execute search query
+     *
+     * @returns search result
+     */
+    query(): Promise<{
+        meta: import("../search/BaseSearch").Meta;
+        results: any[];
+    }>;
+}
+//# sourceMappingURL=PdrS3Search.d.ts.map

package/dist/s3search/PdrS3Search.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PdrS3Search = void 0;
+const DuckDBSearchExecutor_1 = require("./DuckDBSearchExecutor");
+const PdrSearch_1 = require("../search/PdrSearch");
+/**
+ * Class to build and execute DuckDB search query for PDRs
+ */
+class PdrS3Search extends PdrSearch_1.PdrSearch {
+    constructor(event, dbConnection) {
+        super(event);
+        this.duckDBSearchExecutor = new DuckDBSearchExecutor_1.DuckDBSearchExecutor({
+            dbConnection,
+            dbQueryParameters: this.dbQueryParameters,
+            getMetaTemplate: this._metaTemplate.bind(this),
+            translateRecords: this.translatePostgresRecordsToApiRecords.bind(this),
+        });
+    }
+    /**
+     * Build and execute search query
+     *
+     * @returns search result
+     */
+    async query() {
+        return this.duckDBSearchExecutor.query((knexBuilder) => this.buildSearch(knexBuilder));
+    }
+}
+exports.PdrS3Search = PdrS3Search;
+//# sourceMappingURL=PdrS3Search.js.map

package/dist/s3search/ProviderS3Search.d.ts

@@ -0,0 +1,20 @@
+import { DuckDBConnection } from '@duckdb/node-api';
+import { ProviderSearch } from '../search/ProviderSearch';
+import { QueryEvent } from '../types/search';
+/**
+ * Class to build and execute DuckDB search query for providers
+ */
+export declare class ProviderS3Search extends ProviderSearch {
+    private duckDBSearchExecutor;
+    constructor(event: QueryEvent, dbConnection: DuckDBConnection);
+    /**
+     * Build and execute search query
+     *
+     * @returns search result
+     */
+    query(): Promise<{
+        meta: import("../search/BaseSearch").Meta;
+        results: any[];
+    }>;
+}
+//# sourceMappingURL=ProviderS3Search.d.ts.map

package/dist/s3search/ProviderS3Search.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProviderS3Search = void 0;
+const DuckDBSearchExecutor_1 = require("./DuckDBSearchExecutor");
+const ProviderSearch_1 = require("../search/ProviderSearch");
+/**
+ * Class to build and execute DuckDB search query for providers
+ */
+class ProviderS3Search extends ProviderSearch_1.ProviderSearch {
+    constructor(event, dbConnection) {
+        super(event);
+        this.duckDBSearchExecutor = new DuckDBSearchExecutor_1.DuckDBSearchExecutor({
+            dbConnection,
+            dbQueryParameters: this.dbQueryParameters,
+            getMetaTemplate: this._metaTemplate.bind(this),
+            translateRecords: this.translatePostgresRecordsToApiRecords.bind(this),
+        });
+    }
+    /**
+     * Build and execute search query
+     *
+     * @returns search result
+     */
+    async query() {
+        return this.duckDBSearchExecutor.query((knexBuilder) => this.buildSearch(knexBuilder));
+    }
+}
+exports.ProviderS3Search = ProviderS3Search;
+//# sourceMappingURL=ProviderS3Search.js.map

package/dist/s3search/ReconciliationReportS3Search.d.ts

@@ -0,0 +1,20 @@
+import { DuckDBConnection } from '@duckdb/node-api';
+import { ReconciliationReportSearch } from '../search/ReconciliationReportSearch';
+import { QueryEvent } from '../types/search';
+/**
+ * Class to build and execute DuckDB search query for Reconciliation Report
+ */
+export declare class ReconciliationReportS3Search extends ReconciliationReportSearch {
+    private duckDBSearchExecutor;
+    constructor(event: QueryEvent, dbConnection: DuckDBConnection);
+    /**
+     * Build and execute search query
+     *
+     * @returns search result
+     */
+    query(): Promise<{
+        meta: import("../search/BaseSearch").Meta;
+        results: any[];
+    }>;
+}
+//# sourceMappingURL=ReconciliationReportS3Search.d.ts.map