@cumulus/db 18.3.4 → 19.0.0

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.
  *
@@ -25,7 +49,7 @@ import { PostgresProviderRecord } from '../types/provider';
 export declare const translatePostgresGranuleToApiGranule: ({ granulePgRecord, collectionPgRecord, knexOrTransaction, providerPgRecord, collectionPgModel, pdrPgModel, providerPgModel, filePgModel, }: {
     granulePgRecord: PostgresGranuleRecord;
     knexOrTransaction: Knex | Knex.Transaction;
-    collectionPgRecord?: Pick<PostgresCollectionRecord, "version" | "name" | "cumulus_id"> | undefined;
+    collectionPgRecord?: Pick<PostgresCollectionRecord, "cumulus_id" | "version" | "name"> | undefined;
     providerPgRecord?: Pick<PostgresProviderRecord, "name"> | undefined;
     collectionPgModel?: CollectionPgModel | undefined;
     pdrPgModel?: PdrPgModel | undefined;

package/dist/translate/granules.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.translatePostgresGranuleResultToApiGranule = exports.translateApiGranuleToPostgresGranule = exports.translateApiGranuleToPostgresGranuleWithoutNilsRemoved = exports.translatePostgresGranuleToApiGranule = void 0;
+exports.translatePostgresGranuleResultToApiGranule = exports.translateApiGranuleToPostgresGranule = exports.translateApiGranuleToPostgresGranuleWithoutNilsRemoved = exports.translatePostgresGranuleToApiGranule = exports.translatePostgresGranuleToApiGranuleWithoutDbQuery = void 0;
 const Collections_1 = require("@cumulus/message/Collections");
 const util_1 = require("@cumulus/common/util");
 const errors_1 = require("@cumulus/errors");
@@ -15,6 +15,46 @@ const provider_1 = require("../models/provider");
 const file_1 = require("../models/file");
 const execution_1 = require("../lib/execution");
 const file_2 = require("./file");
+/**
+ * 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
+ */
+const translatePostgresGranuleToApiGranuleWithoutDbQuery = ({ granulePgRecord, collectionPgRecord, executionUrls = [], files = [], pdr, providerPgRecord, }) => (0, util_1.removeNilProperties)({
+    beginningDateTime: granulePgRecord.beginning_date_time?.toISOString(),
+    cmrLink: granulePgRecord.cmr_link,
+    collectionId: (0, Collections_1.constructCollectionId)(collectionPgRecord.name, collectionPgRecord.version),
+    createdAt: granulePgRecord.created_at?.getTime(),
+    duration: granulePgRecord.duration,
+    endingDateTime: granulePgRecord.ending_date_time?.toISOString(),
+    error: granulePgRecord.error,
+    execution: executionUrls[0] ? executionUrls[0].url : undefined,
+    files: files.length > 0 ? files.map((file) => (0, file_2.translatePostgresFileToApiFile)(file)) : [],
+    granuleId: granulePgRecord.granule_id,
+    lastUpdateDateTime: granulePgRecord.last_update_date_time?.toISOString(),
+    pdrName: pdr ? pdr.name : undefined,
+    processingEndDateTime: granulePgRecord.processing_end_date_time?.toISOString(),
+    processingStartDateTime: granulePgRecord.processing_start_date_time?.toISOString(),
+    productionDateTime: granulePgRecord.production_date_time?.toISOString(),
+    productVolume: granulePgRecord.product_volume,
+    provider: providerPgRecord ? providerPgRecord.name : undefined,
+    published: granulePgRecord.published,
+    queryFields: granulePgRecord.query_fields,
+    status: granulePgRecord.status,
+    timestamp: granulePgRecord.timestamp?.getTime(),
+    timeToArchive: granulePgRecord.time_to_archive,
+    timeToPreprocess: granulePgRecord.time_to_process,
+    updatedAt: granulePgRecord.updated_at?.getTime(),
+});
+exports.translatePostgresGranuleToApiGranuleWithoutDbQuery = translatePostgresGranuleToApiGranuleWithoutDbQuery;
 /**
  * Generate an API Granule object from a Postgres Granule with associated Files.
  *
@@ -52,33 +92,14 @@ const translatePostgresGranuleToApiGranule = async ({ granulePgRecord, collectio
     else if (granulePgRecord.provider_cumulus_id) {
         provider = await providerPgModel.get(knexOrTransaction, { cumulus_id: granulePgRecord.provider_cumulus_id });
     }
-    const apiGranule = (0, util_1.removeNilProperties)({
-        beginningDateTime: granulePgRecord.beginning_date_time?.toISOString(),
-        cmrLink: granulePgRecord.cmr_link,
-        collectionId: (0, Collections_1.constructCollectionId)(collection.name, collection.version),
-        createdAt: granulePgRecord.created_at?.getTime(),
-        duration: granulePgRecord.duration,
-        endingDateTime: granulePgRecord.ending_date_time?.toISOString(),
-        error: granulePgRecord.error,
-        execution: executionUrls[0] ? executionUrls[0].url : undefined,
-        files: files.length > 0 ? files.map((file) => (0, file_2.translatePostgresFileToApiFile)(file)) : [],
-        granuleId: granulePgRecord.granule_id,
-        lastUpdateDateTime: granulePgRecord.last_update_date_time?.toISOString(),
-        pdrName: pdr ? pdr.name : undefined,
-        processingEndDateTime: granulePgRecord.processing_end_date_time?.toISOString(),
-        processingStartDateTime: granulePgRecord.processing_start_date_time?.toISOString(),
-        productionDateTime: granulePgRecord.production_date_time?.toISOString(),
-        productVolume: granulePgRecord.product_volume,
-        provider: provider ? provider.name : undefined,
-        published: granulePgRecord.published,
-        queryFields: granulePgRecord.query_fields,
-        status: granulePgRecord.status,
-        timestamp: granulePgRecord.timestamp?.getTime(),
-        timeToArchive: granulePgRecord.time_to_archive,
-        timeToPreprocess: granulePgRecord.time_to_process,
-        updatedAt: granulePgRecord.updated_at?.getTime(),
+    return (0, exports.translatePostgresGranuleToApiGranuleWithoutDbQuery)({
+        granulePgRecord,
+        collectionPgRecord: collection,
+        executionUrls,
+        files,
+        pdr,
+        providerPgRecord: provider,
     });
-    return apiGranule;
 };
 exports.translatePostgresGranuleToApiGranule = translatePostgresGranuleToApiGranule;
 /**

package/dist/types/search.d.ts

@@ -0,0 +1,52 @@
+export declare type QueryStringParameters = {
+    field?: string;
+    fields?: string;
+    infix?: string;
+    limit?: string;
+    page?: string;
+    order?: string;
+    prefix?: string;
+    includeFullRecord?: string;
+    sort_by?: string;
+    sort_key?: string[];
+    [key: string]: string | string[] | undefined;
+};
+export declare type QueryEvent = {
+    queryStringParameters?: QueryStringParameters;
+};
+export declare type QueriableType = boolean | Date | number | string;
+export declare type RangeType = {
+    gte?: Omit<QueriableType, 'boolean'>;
+    lte?: Omit<QueriableType, 'boolean'>;
+};
+export declare type SortType = {
+    column: string;
+    order?: string;
+};
+export declare type DbQueryParameters = {
+    fields?: string[];
+    infix?: string;
+    limit?: number;
+    includeFullRecord?: boolean;
+    estimateTableRowCount?: boolean;
+    exists?: {
+        [key: string]: boolean;
+    };
+    not?: {
+        [key: string]: QueriableType | undefined;
+    };
+    offset?: number;
+    page?: number;
+    prefix?: string;
+    range?: {
+        [key: string]: RangeType;
+    };
+    sort?: SortType[];
+    term?: {
+        [key: string]: QueriableType | undefined;
+    };
+    terms?: {
+        [key: string]: QueriableType[];
+    };
+};
+//# sourceMappingURL=search.d.ts.map

package/dist/types/search.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=search.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cumulus/db",
-  "version": "18.3.4",
+  "version": "19.0.0",
   "description": "Utilities for working with the Cumulus DB",
   "license": "Apache-2.0",
   "main": "./dist/index.js",
@@ -32,13 +32,13 @@
     "node": ">=20.12.2"
   },
   "dependencies": {
-    "@aws-sdk/client-secrets-manager": "^3.447.0",
-    "@cumulus/aws-client": "18.3.4",
-    "@cumulus/common": "18.3.4",
-    "@cumulus/errors": "18.3.4",
-    "@cumulus/logger": "18.3.4",
-    "@cumulus/message": "18.3.4",
-    "@cumulus/types": "18.3.4",
+    "@aws-sdk/client-secrets-manager": "^3.621.0",
+    "@cumulus/aws-client": "19.0.0",
+    "@cumulus/common": "19.0.0",
+    "@cumulus/errors": "19.0.0",
+    "@cumulus/logger": "19.0.0",
+    "@cumulus/message": "19.0.0",
+    "@cumulus/types": "19.0.0",
     "crypto-random-string": "^3.2.0",
     "is-valid-hostname": "1.0.2",
     "knex": "2.4.1",
@@ -50,5 +50,5 @@
   "devDependencies": {
     "@types/uuid": "^8.0.0"
   },
-  "gitHead": "d2ddab76522b140fd7b92d865a8e0ec5d80485c7"
+  "gitHead": "3a619db6e6fa20846eb75802e89d5a065fd62fcc"
 }