@cumulus/db 18.4.0 → 19.0.0

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

@@ -0,0 +1,16 @@
+/**
+ * Map query string field to db field
+ *
+ * @param type - query record type
+ * @param queryField - query field
+ * @param queryField.name - query field value
+ * @param [queryField.value] - query field value
+ * @returns db field
+ */
+export declare const mapQueryStringFieldToDbField: (type: string, queryField: {
+    name: string;
+    value?: string;
+}) => {
+    [key: string]: any;
+} | undefined;
+//# sourceMappingURL=field-mapping.d.ts.map

package/dist/search/field-mapping.js

@@ -0,0 +1,304 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapQueryStringFieldToDbField = void 0;
+const Collections_1 = require("@cumulus/message/Collections");
+const logger_1 = __importDefault(require("@cumulus/logger"));
+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 = {
+    beginningDateTime: (value) => ({
+        beginning_date_time: value,
+    }),
+    cmrLink: (value) => ({
+        cmr_link: value,
+    }),
+    createdAt: (value) => ({
+        created_at: value && new Date(Number(value)),
+    }),
+    duration: (value) => ({
+        duration: value && Number(value),
+    }),
+    endingDateTime: (value) => ({
+        ending_date_time: value,
+    }),
+    granuleId: (value) => ({
+        granule_id: value,
+    }),
+    _id: (value) => ({
+        granule_id: value,
+    }),
+    lastUpdateDateTime: (value) => ({
+        last_update_date_time: value,
+    }),
+    processingEndDateTime: (value) => ({
+        processing_end_date_time: value,
+    }),
+    processingStartDateTime: (value) => ({
+        processing_start_date_time: value,
+    }),
+    productionDateTime: (value) => ({
+        production_date_time: value,
+    }),
+    productVolume: (value) => ({
+        product_volume: value,
+    }),
+    published: (value) => ({
+        published: (value === 'true'),
+    }),
+    status: (value) => ({
+        status: value,
+    }),
+    timestamp: (value) => ({
+        updated_at: value && new Date(Number(value)),
+    }),
+    timeToArchive: (value) => ({
+        time_to_archive: Number(value),
+    }),
+    timeToPreprocess: (value) => ({
+        time_to_process: Number(value),
+    }),
+    updatedAt: (value) => ({
+        updated_at: value && new Date(Number(value)),
+    }),
+    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)) || {};
+        return {
+            collectionName: name,
+            collectionVersion: version,
+        };
+    },
+    provider: (value) => ({
+        providerName: value,
+    }),
+    pdrName: (value) => ({
+        pdrName: value,
+    }),
+};
+const asyncOperationMapping = {
+    createdAt: (value) => ({
+        created_at: value && new Date(Number(value)),
+    }),
+    id: (value) => ({
+        id: value,
+    }),
+    operationType: (value) => ({
+        operation_type: value,
+    }),
+    status: (value) => ({
+        status: value,
+    }),
+    taskArn: (value) => ({
+        task_arn: value,
+    }),
+    timestamp: (value) => ({
+        updated_at: value && new Date(Number(value)),
+    }),
+    updatedAt: (value) => ({
+        updated_at: value && new Date(Number(value)),
+    }),
+};
+const collectionMapping = {
+    createdAt: (value) => ({
+        created_at: value && new Date(Number(value)),
+    }),
+    name: (value) => ({
+        name: value,
+    }),
+    version: (value) => ({
+        version: value,
+    }),
+    _id: (value) => {
+        const { name, version } = (value && (0, Collections_1.deconstructCollectionId)(value)) || {};
+        return {
+            collectionName: name,
+            collectionVersion: version,
+        };
+    },
+    duplicateHandling: (value) => ({
+        duplicate_handling: value,
+    }),
+    granuleId: (value) => ({
+        granule_id_validation_regex: value,
+    }),
+    granuleIdExtraction: (value) => ({
+        granule_id_extraction_regex: value,
+    }),
+    timestamp: (value) => ({
+        updated_at: value && new Date(Number(value)),
+    }),
+    updatedAt: (value) => ({
+        updated_at: value && new Date(Number(value)),
+    }),
+    reportToEms: (value) => ({
+        report_to_ems: (value === 'true'),
+    }),
+    process: (value) => ({
+        process: value,
+    }),
+    sampleFileName: (value) => ({
+        sample_file_name: value,
+    }),
+    url_path: (value) => ({
+        url_path: value,
+    }),
+};
+// TODO add and verify all queryable fields for the following record types
+const executionMapping = {
+    arn: (value) => ({
+        arn: value,
+    }),
+    createdAt: (value) => ({
+        created_at: value && new Date(Number(value)),
+    }),
+    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,
+    }),
+    type: (value) => ({
+        workflow_name: value,
+    }),
+    status: (value) => ({
+        status: value,
+    }),
+    timestamp: (value) => ({
+        updated_at: value && new Date(Number(value)),
+    }),
+    updatedAt: (value) => ({
+        updated_at: value && new Date(Number(value)),
+    }),
+    // The following fields require querying other tables
+    asyncOperationId: (value) => ({
+        asyncOperationId: value,
+    }),
+    parentArn: (value) => ({
+        parentArn: value,
+    }),
+    collectionId: (value) => {
+        const { name, version } = (value && (0, Collections_1.deconstructCollectionId)(value)) || {};
+        return {
+            collectionName: name,
+            collectionVersion: version,
+        };
+    },
+};
+const pdrMapping = {
+    createdAt: (value) => ({
+        created_at: value && new Date(Number(value)),
+    }),
+    pdrName: (value) => ({
+        name: value,
+    }),
+    status: (value) => ({
+        status: value,
+    }),
+    timestamp: (value) => ({
+        updated_at: value && new Date(Number(value)),
+    }),
+    updatedAt: (value) => ({
+        updated_at: value && new Date(Number(value)),
+    }),
+    // The following fields require querying other tables
+    collectionId: (value) => {
+        const { name, version } = (value && (0, Collections_1.deconstructCollectionId)(value)) || {};
+        return {
+            collectionName: name,
+            collectionVersion: version,
+        };
+    },
+    provider: (value) => ({
+        providerName: value,
+    }),
+};
+const providerMapping = {
+    createdAt: (value) => ({
+        created_at: value && new Date(Number(value)),
+    }),
+    id: (value) => ({
+        name: value,
+    }),
+    timestamp: (value) => ({
+        updated_at: value && new Date(Number(value)),
+    }),
+    updatedAt: (value) => ({
+        updated_at: value && new Date(Number(value)),
+    }),
+};
+const ruleMapping = {
+    createdAt: (value) => ({
+        created_at: value && new Date(Number(value)),
+    }),
+    name: (value) => ({
+        name: value,
+    }),
+    state: (value) => ({
+        enabled: (value === 'ENABLED'),
+    }),
+    timestamp: (value) => ({
+        updated_at: value && new Date(Number(value)),
+    }),
+    updatedAt: (value) => ({
+        updated_at: value && new Date(Number(value)),
+    }),
+    // The following fields require querying other tables
+    collectionId: (value) => {
+        const { name, version } = (value && (0, Collections_1.deconstructCollectionId)(value)) || {};
+        return {
+            collectionName: name,
+            collectionVersion: version,
+        };
+    },
+    provider: (value) => ({
+        providerName: value,
+    }),
+};
+// type and its mapping
+const supportedMappings = {
+    granule: granuleMapping,
+    asyncOperation: asyncOperationMapping,
+    collection: collectionMapping,
+    execution: executionMapping,
+    pdr: pdrMapping,
+    provider: providerMapping,
+    rule: ruleMapping,
+};
+/**
+ * Map query string field to db field
+ *
+ * @param type - query record type
+ * @param queryField - query field
+ * @param queryField.name - query field value
+ * @param [queryField.value] - query field value
+ * @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)}`);
+        return undefined;
+    }
+    return supportedMappings[type] && supportedMappings[type][queryField.name](queryField.value);
+};
+exports.mapQueryStringFieldToDbField = mapQueryStringFieldToDbField;
+//# sourceMappingURL=field-mapping.js.map

package/dist/search/queries.d.ts

@@ -0,0 +1,10 @@
+import { DbQueryParameters, QueryStringParameters } from '../types/search';
+/**
+ * Convert api query string parameters to db query parameters
+ *
+ * @param type - query record type
+ * @param queryStringParameters - query string parameters
+ * @returns db query parameters
+ */
+export declare const convertQueryStringToDbQueryParameters: (type: string, queryStringParameters: QueryStringParameters) => DbQueryParameters;
+//# sourceMappingURL=queries.d.ts.map

package/dist/search/queries.js

@@ -0,0 +1,235 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertQueryStringToDbQueryParameters = void 0;
+const omit_1 = __importDefault(require("lodash/omit"));
+const logger_1 = __importDefault(require("@cumulus/logger"));
+const field_mapping_1 = require("./field-mapping");
+const log = new logger_1.default({ sender: '@cumulus/db/queries' });
+// reserved words which are not record fields
+const reservedWords = [
+    'limit',
+    'page',
+    'skip',
+    'sort_by',
+    'sort_key',
+    'order',
+    'prefix',
+    'infix',
+    'estimateTableRowCount',
+    'fields',
+    'includeFullRecord',
+    'searchContext',
+];
+/**
+ * regexp for matching api query string parameter to query type
+ */
+const regexes = {
+    terms: /^(.*)__in$/,
+    term: /^((?!__).)*$/,
+    not: /^(.*)__not$/,
+    exists: /^(.*)__exists$/,
+    range: /^(.*)__(from|to)$/,
+};
+/**
+ * Convert 'exists' query fields to db query parameters from api query string fields
+ *
+ * @param type - query record type
+ * @param queryStringFields - api query fields
+ * @returns 'exists' query parameter
+ */
+const convertExists = (type, queryStringFields) => {
+    const exists = queryStringFields.reduce((acc, queryField) => {
+        const match = queryField.name.match(regexes.exists);
+        if (!match)
+            return acc;
+        // get corresponding db field name, e.g. granuleId => granule_id
+        const dbField = (0, field_mapping_1.mapQueryStringFieldToDbField)(type, { name: match[1] });
+        if (!dbField)
+            return acc;
+        Object.keys(dbField).forEach((key) => { dbField[key] = (queryField.value === 'true'); });
+        return { ...acc, ...dbField };
+    }, {});
+    return { exists };
+};
+/**
+ * Convert 'not' query fields to db query parameters from api query string fields
+ *
+ * @param type - query record type
+ * @param queryStringFields - api query fields
+ * @returns 'not' query parameter
+ */
+const convertNotMatch = (type, queryStringFields) => {
+    const not = queryStringFields.reduce((acc, queryField) => {
+        const match = queryField.name.match(regexes.not);
+        if (!match)
+            return acc;
+        // get corresponding db field name, e.g. granuleId => granule_id
+        const queryParam = (0, field_mapping_1.mapQueryStringFieldToDbField)(type, { ...queryField, name: match[1] });
+        return { ...acc, ...queryParam };
+    }, {});
+    return { not };
+};
+/**
+ * Convert range query fields to db query parameters from api query string fields
+ *
+ * @param type - query record type
+ * @param queryStringFields - api query fields
+ * @returns range query parameter
+ */
+const convertRange = (type, queryStringFields) => {
+    const range = queryStringFields.reduce((acc, queryField) => {
+        const match = queryField.name.match(regexes.range);
+        if (!match)
+            return acc;
+        // get corresponding db field name, e.g. timestamp => updated_at
+        const dbField = (0, field_mapping_1.mapQueryStringFieldToDbField)(type, { ...queryField, name: match[1] });
+        if (!dbField)
+            return acc;
+        const dbFieldName = Object.keys(dbField)[0];
+        // build a range field, e.g.
+        // { timestamp__from: '1712708508310', timestamp__to: '1712712108310' } =>
+        // { updated_at: {
+        //     gte: new Date(1712708508310),
+        //     lte: new Date(1712712108310),
+        //   },
+        // }
+        const rangeField = { [dbFieldName]: acc[dbFieldName] || {} };
+        if (match[2] === 'from') {
+            rangeField[dbFieldName].gte = dbField[dbFieldName];
+        }
+        if (match[2] === 'to') {
+            rangeField[dbFieldName].lte = dbField[dbFieldName];
+        }
+        return { ...acc, ...rangeField };
+    }, {});
+    return { range };
+};
+/**
+ * Convert term query fields to db query parameters from api query string fields
+ *
+ * @param type - query record type
+ * @param queryStringFields - api query fields
+ * @returns term query parameter
+ */
+const convertTerm = (type, queryStringFields) => {
+    const term = queryStringFields.reduce((acc, queryField) => {
+        const queryParam = (0, field_mapping_1.mapQueryStringFieldToDbField)(type, queryField);
+        return { ...acc, ...queryParam };
+    }, {});
+    return { term };
+};
+/**
+ * Convert terms query fields to db query parameters from api query string fields
+ *
+ * @param type - query record type
+ * @param queryStringFields - api query fields
+ * @returns terms query parameter
+ */
+const convertTerms = (type, queryStringFields) => {
+    const terms = queryStringFields.reduce((acc, queryField) => {
+        const match = queryField.name.match(regexes.terms);
+        if (!match)
+            return acc;
+        // build a terms field, e.g.
+        // { granuleId__in: 'granuleId1,granuleId2' } =>
+        // [[granule_id, granuleId1], [granule_id, granuleId2]] =>
+        // { granule_id: [granuleId1, granuleId2] }
+        // this converts collectionId into name and version fields
+        const name = match[1];
+        const values = queryField.value.split(',');
+        const dbFieldValues = values
+            .map((value) => {
+            const dbField = (0, field_mapping_1.mapQueryStringFieldToDbField)(type, { name, value });
+            return Object.entries(dbField ?? {});
+        })
+            .filter(Boolean)
+            .flat();
+        if (dbFieldValues.length === 0)
+            return acc;
+        dbFieldValues.forEach(([field, value]) => {
+            acc[field] = acc[field] ?? [];
+            acc[field].push(value);
+        });
+        return acc;
+    }, {});
+    return { terms };
+};
+/**
+ * Convert sort query fields to db query parameters from api query string fields
+ *
+ * @param type - query record type
+ * @param queryStringParameters - query string parameters
+ * @returns sort query parameter
+ */
+const convertSort = (type, queryStringParameters) => {
+    const sortArray = [];
+    const { sort_by: sortBy, sort_key: sortKey } = queryStringParameters;
+    let { order } = queryStringParameters;
+    if (sortBy) {
+        order = order ?? 'asc';
+        const queryParam = (0, field_mapping_1.mapQueryStringFieldToDbField)(type, { name: sortBy });
+        Object.keys(queryParam ?? {}).map((key) => sortArray.push({ column: key, order }));
+    }
+    else if (sortKey) {
+        sortKey.map((item) => {
+            order = item.startsWith('-') ? 'desc' : 'asc';
+            const queryParam = (0, field_mapping_1.mapQueryStringFieldToDbField)(type, { name: item.replace(/^[+-]/, '') });
+            return Object.keys(queryParam ?? {}).map((key) => sortArray.push({ column: key, order }));
+        });
+    }
+    return sortArray;
+};
+/**
+ * functions for converting from api query string parameters to db query parameters
+ * for each type of query
+ */
+const convert = {
+    exists: convertExists,
+    not: convertNotMatch,
+    range: convertRange,
+    term: convertTerm,
+    terms: convertTerms,
+};
+/**
+ * Convert api query string parameters to db query parameters
+ *
+ * @param type - query record type
+ * @param queryStringParameters - query string parameters
+ * @returns db query parameters
+ */
+const convertQueryStringToDbQueryParameters = (type, queryStringParameters) => {
+    const { limit, page, prefix, infix, fields, estimateTableRowCount, includeFullRecord, } = queryStringParameters;
+    const dbQueryParameters = {};
+    dbQueryParameters.page = Number.parseInt(page ?? '1', 10);
+    dbQueryParameters.limit = Number.parseInt(limit ?? '10', 10);
+    dbQueryParameters.offset = (dbQueryParameters.page - 1) * dbQueryParameters.limit;
+    if (typeof infix === 'string')
+        dbQueryParameters.infix = infix;
+    if (typeof prefix === 'string')
+        dbQueryParameters.prefix = prefix;
+    if (typeof fields === 'string')
+        dbQueryParameters.fields = fields.split(',');
+    dbQueryParameters.estimateTableRowCount = (estimateTableRowCount === 'true');
+    dbQueryParameters.includeFullRecord = (includeFullRecord === 'true');
+    dbQueryParameters.sort = convertSort(type, queryStringParameters);
+    // remove reserved words (that are not fields)
+    const fieldParams = (0, omit_1.default)(queryStringParameters, reservedWords);
+    // determine which search strategy should be applied
+    // options are term, terms, range, exists and not in
+    const fieldsList = Object.entries(fieldParams).map(([name, value]) => ({ name, value }));
+    // for each search strategy, get all parameters and convert them to db parameters
+    Object.keys(regexes).forEach((k) => {
+        const matchedFields = fieldsList.filter((f) => f.name.match(regexes[k]));
+        if (matchedFields && matchedFields.length > 0 && convert[k]) {
+            const queryParams = convert[k](type, matchedFields, regexes[k]);
+            Object.assign(dbQueryParameters, queryParams);
+        }
+    });
+    log.debug(`convertQueryStringToDbQueryParameters returns ${JSON.stringify(dbQueryParameters)}`);
+    return dbQueryParameters;
+};
+exports.convertQueryStringToDbQueryParameters = convertQueryStringToDbQueryParameters;
+//# sourceMappingURL=queries.js.map

package/dist/translate/executions.d.ts

@@ -4,6 +4,12 @@ import { PostgresExecution, PostgresExecutionRecord } from '../types/execution';
 import { ExecutionPgModel } from '../models/execution';
 import { CollectionPgModel } from '../models/collection';
 import { AsyncOperationPgModel } from '../models/async_operation';
+export declare const translatePostgresExecutionToApiExecutionWithoutDbQuery: ({ executionRecord, collectionId, asyncOperationId, parentArn, }: {
+    executionRecord: PostgresExecutionRecord;
+    collectionId: string | undefined;
+    asyncOperationId: string | undefined;
+    parentArn: string | undefined;
+}) => ApiExecutionRecord;
 export declare const translatePostgresExecutionToApiExecution: (executionRecord: PostgresExecutionRecord, knex: Knex, collectionPgModel?: CollectionPgModel, asyncOperationPgModel?: AsyncOperationPgModel, executionPgModel?: ExecutionPgModel) => Promise<ApiExecutionRecord>;
 /**
  * Translate execution record from API to RDS.

package/dist/translate/executions.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.translateApiExecutionToPostgresExecution = exports.translateApiExecutionToPostgresExecutionWithoutNilsRemoved = exports.translatePostgresExecutionToApiExecution = void 0;
+exports.translateApiExecutionToPostgresExecution = exports.translateApiExecutionToPostgresExecutionWithoutNilsRemoved = exports.translatePostgresExecutionToApiExecution = exports.translatePostgresExecutionToApiExecutionWithoutDbQuery = void 0;
 const isNil_1 = __importDefault(require("lodash/isNil"));
 const isNull_1 = __importDefault(require("lodash/isNull"));
 const errors_1 = require("@cumulus/errors");
@@ -14,28 +14,7 @@ const Collections_1 = require("@cumulus/message/Collections");
 const execution_1 = require("../models/execution");
 const collection_1 = require("../models/collection");
 const async_operation_1 = require("../models/async_operation");
-const translatePostgresExecutionToApiExecution = async (executionRecord, knex, collectionPgModel = new collection_1.CollectionPgModel(), asyncOperationPgModel = new async_operation_1.AsyncOperationPgModel(), executionPgModel = new execution_1.ExecutionPgModel()) => {
-    let parentArn;
-    let collectionId;
-    let asyncOperationId;
-    if (executionRecord.collection_cumulus_id) {
-        const collection = await collectionPgModel.get(knex, {
-            cumulus_id: executionRecord.collection_cumulus_id,
-        });
-        collectionId = (0, Collections_1.constructCollectionId)(collection.name, collection.version);
-    }
-    if (executionRecord.async_operation_cumulus_id) {
-        const asyncOperation = await asyncOperationPgModel.get(knex, {
-            cumulus_id: executionRecord.async_operation_cumulus_id,
-        });
-        asyncOperationId = asyncOperation.id;
-    }
-    if (executionRecord.parent_cumulus_id) {
-        const parentExecution = await executionPgModel.get(knex, {
-            cumulus_id: executionRecord.parent_cumulus_id,
-        });
-        parentArn = parentExecution.arn;
-    }
+const translatePostgresExecutionToApiExecutionWithoutDbQuery = ({ executionRecord, collectionId, asyncOperationId, parentArn, }) => {
     const postfix = executionRecord.arn.split(':').pop();
     if (!postfix) {
         throw new Error(`Execution ARN record ${executionRecord.arn} has an invalid postfix and API cannot generate the required 'name' field`);
@@ -61,6 +40,36 @@ const translatePostgresExecutionToApiExecution = async (executionRecord, knex, c
     };
     return (0, util_1.removeNilProperties)(translatedRecord);
 };
+exports.translatePostgresExecutionToApiExecutionWithoutDbQuery = translatePostgresExecutionToApiExecutionWithoutDbQuery;
+const translatePostgresExecutionToApiExecution = async (executionRecord, knex, collectionPgModel = new collection_1.CollectionPgModel(), asyncOperationPgModel = new async_operation_1.AsyncOperationPgModel(), executionPgModel = new execution_1.ExecutionPgModel()) => {
+    let collectionId;
+    let asyncOperationId;
+    let parentArn;
+    if (executionRecord.collection_cumulus_id) {
+        const collection = await collectionPgModel.get(knex, {
+            cumulus_id: executionRecord.collection_cumulus_id,
+        });
+        collectionId = (0, Collections_1.constructCollectionId)(collection.name, collection.version);
+    }
+    if (executionRecord.async_operation_cumulus_id) {
+        const asyncOperation = await asyncOperationPgModel.get(knex, {
+            cumulus_id: executionRecord.async_operation_cumulus_id,
+        });
+        asyncOperationId = asyncOperation.id;
+    }
+    if (executionRecord.parent_cumulus_id) {
+        const parentExecution = await executionPgModel.get(knex, {
+            cumulus_id: executionRecord.parent_cumulus_id,
+        });
+        parentArn = parentExecution.arn;
+    }
+    return (0, exports.translatePostgresExecutionToApiExecutionWithoutDbQuery)({
+        executionRecord,
+        collectionId,
+        asyncOperationId,
+        parentArn,
+    });
+};
 exports.translatePostgresExecutionToApiExecution = translatePostgresExecutionToApiExecution;
 /**
  * Validate translation api record doesn't contain invalid null/undefined values based

package/dist/translate/granules.d.ts

@@ -5,9 +5,33 @@ import { PdrPgModel } from '../models/pdr';
 import { ProviderPgModel } from '../models/provider';
 import { FilePgModel } from '../models/file';
 import { PostgresCollectionRecord } from '../types/collection';
+import { PostgresExecutionRecord } from '../types/execution';
 import { PostgresGranule, PostgresGranuleRecord } from '../types/granule';
+import { PostgresFileRecord } from '../types/file';
+import { PostgresPdrRecord } from '../types/pdr';
 import { GranuleWithProviderAndCollectionInfo } from '../types/query';
 import { PostgresProviderRecord } from '../types/provider';
+/**
+ * Generate an API Granule object from the granule and associated Postgres objects without
+ * querying the database
+ *
+ * @param params - params
+ * @param params.granulePgRecord - Granule from Postgres
+ * @param params.collectionPgRecord - Collection from Postgres
+ * @param [params.executionUrls] - executionUrls from Postgres
+ * @param [params.files] - granule files from Postgres
+ * @param [params.pdr] - pdr from Postgres
+ * @param [params.providerPgRecord] - provider from Postgres
+ * @returns An API Granule with associated Files
+ */
+export declare const translatePostgresGranuleToApiGranuleWithoutDbQuery: ({ granulePgRecord, collectionPgRecord, executionUrls, files, pdr, providerPgRecord, }: {
+    granulePgRecord: PostgresGranuleRecord;
+    collectionPgRecord: Pick<PostgresCollectionRecord, 'cumulus_id' | 'name' | 'version'>;
+    executionUrls?: Partial<PostgresExecutionRecord>[] | undefined;
+    files?: PostgresFileRecord[] | undefined;
+    pdr?: Pick<PostgresPdrRecord, "name"> | undefined;
+    providerPgRecord?: Pick<PostgresProviderRecord, "name"> | undefined;
+}) => ApiGranuleRecord;
 /**
  * Generate an API Granule object from a Postgres Granule with associated Files.
  *