@cumulus/db 10.1.0 → 10.1.1-alpha.0

package/dist/lib/granule.js

@@ -1,10 +1,22 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getApiGranuleExecutionCumulusIds = exports.getApiGranuleCumulusIds = exports.upsertGranuleWithExecutionJoinRecord = void 0;
+exports.getGranulesByApiPropertiesQuery = exports.getApiGranuleExecutionCumulusIds = exports.getUniqueGranuleByGranuleId = exports.getApiGranuleCumulusIds = exports.upsertGranuleWithExecutionJoinRecord = exports.getGranuleCollectionId = void 0;
+const Collections_1 = require("@cumulus/message/Collections");
+const errors_1 = require("@cumulus/errors");
+const logger_1 = __importDefault(require("@cumulus/logger"));
 const collection_1 = require("../models/collection");
 const granule_1 = require("../models/granule");
 const granules_executions_1 = require("../models/granules-executions");
-const { deconstructCollectionId } = require('@cumulus/message/Collections');
+const { TableNames } = require('../tables');
+const getGranuleCollectionId = async (knexOrTransaction, granule) => {
+    const collectionPgModel = new collection_1.CollectionPgModel();
+    const collection = await collectionPgModel.get(knexOrTransaction, { cumulus_id: granule.collection_cumulus_id });
+    return (0, Collections_1.constructCollectionId)(collection.name, collection.version);
+};
+exports.getGranuleCollectionId = getGranuleCollectionId;
 /**
  * Upsert a granule and a record in the granules/executions join table.
  *
@@ -14,24 +26,24 @@ const { deconstructCollectionId } = require('@cumulus/message/Collections');
  * @param {Object} [granulePgModel] - Granule PG model class instance
  * @param {Object} [granulesExecutionsPgModel]
  *   Granules/executions PG model class instance
- * @returns {Promise<number[]>}
+ * @returns {Promise<PostgresGranuleRecord[]>}
  */
 const upsertGranuleWithExecutionJoinRecord = async (knexTransaction, granule, executionCumulusId, granulePgModel = new granule_1.GranulePgModel(), granulesExecutionsPgModel = new granules_executions_1.GranulesExecutionsPgModel()) => {
-    const [granuleCumulusId] = await granulePgModel.upsert(knexTransaction, granule, executionCumulusId);
+    const [pgGranule] = await granulePgModel.upsert(knexTransaction, granule, executionCumulusId);
     // granuleCumulusId could be undefined if the upsert affected no rows due to its
     // conditional logic. In that case, we assume that the execution history for the
     // granule was already written and return early. Execution history cannot be written
     // without granuleCumulusId regardless.
-    if (!granuleCumulusId) {
+    if (!pgGranule) {
         return [];
     }
     if (executionCumulusId) {
         await granulesExecutionsPgModel.upsert(knexTransaction, {
-            granule_cumulus_id: granuleCumulusId,
+            granule_cumulus_id: pgGranule.cumulus_id,
             execution_cumulus_id: executionCumulusId,
         });
     }
-    return [granuleCumulusId];
+    return [pgGranule];
 };
 exports.upsertGranuleWithExecutionJoinRecord = upsertGranuleWithExecutionJoinRecord;
 /**
@@ -50,7 +62,7 @@ const getApiGranuleCumulusIds = async (knexOrTransaction, granules, collectionPg
         const { collectionId } = granule;
         let collectionCumulusId = collectionMap[collectionId];
         if (!collectionCumulusId) {
-            const { name, version } = deconstructCollectionId(collectionId);
+            const { name, version } = (0, Collections_1.deconstructCollectionId)(collectionId);
             collectionCumulusId = await collectionPgModel.getRecordCumulusId(knexOrTransaction, { name, version });
             collectionMap[collectionId] = collectionCumulusId;
         }
@@ -62,6 +74,30 @@ const getApiGranuleCumulusIds = async (knexOrTransaction, granules, collectionPg
     return [...new Set(granuleCumulusIds)];
 };
 exports.getApiGranuleCumulusIds = getApiGranuleCumulusIds;
+/**
+ * Get one Granule for a granule_id. If more than one or none are found, throw an error
+ *
+ * @param {Knex | Knex.Transaction} knexOrTransaction -
+ *  DB client or transaction
+ * @param {string} granuleId - a Granule ID
+ * @param {GranulePgModel} granulePgModel - Granule PG model class instance
+ * @returns {Promise<PostgresGranuleRecord>}
+ */
+const getUniqueGranuleByGranuleId = async (knexOrTransaction, granuleId, granulePgModel = new granule_1.GranulePgModel()) => {
+    const logger = new logger_1.default({ sender: '@cumulus/api/granules' });
+    const PgGranuleRecords = await granulePgModel.search(knexOrTransaction, {
+        granule_id: granuleId,
+    });
+    if (PgGranuleRecords.length > 1) {
+        logger.warn(`Granule ID ${granuleId} is not unique across collections, cannot make an update action based on granule Id alone`);
+        throw new Error(`Failed to write ${granuleId} due to granuleId duplication on postgres granule record`);
+    }
+    if (PgGranuleRecords.length === 0) {
+        throw new errors_1.RecordDoesNotExist(`Granule ${granuleId} does not exist or was already deleted`);
+    }
+    return PgGranuleRecords[0];
+};
+exports.getUniqueGranuleByGranuleId = getUniqueGranuleByGranuleId;
 /**
  * Get cumulus IDs for all executions associated to a set of granules
  *
@@ -81,4 +117,64 @@ const getApiGranuleExecutionCumulusIds = async (knexOrTransaction, granules, col
     return executionCumulusIds;
 };
 exports.getApiGranuleExecutionCumulusIds = getApiGranuleExecutionCumulusIds;
+/**
+ * Helper to build a query to search granules by various API granule record properties.
+ *
+ * @param {Knex} knex - DB client
+ * @param {Object} searchParams
+ * @param {string | Array<string>} [searchParams.collectionIds] - Collection ID
+ * @param {string | Array<string>} [searchParams.granuleIds] - array of granule IDs
+ * @param {string} [searchParams.providerName] - Provider name
+ * @param {UpdatedAtRange} [searchParams.updatedAtRange] - Date range for updated_at column
+ * @param {string} [searchParams.status] - Granule status to search by
+ * @param {string | Array<string>} [sortByFields] - Field(s) to sort by
+ * @returns {Knex.QueryBuilder}
+ */
+const getGranulesByApiPropertiesQuery = (knex, { collectionIds, granuleIds, providerNames, updatedAtRange = {}, status, }, sortByFields) => {
+    const { granules: granulesTable, collections: collectionsTable, providers: providersTable, } = TableNames;
+    return knex(granulesTable)
+        .select(`${granulesTable}.*`)
+        .select({
+        providerName: `${providersTable}.name`,
+        collectionName: `${collectionsTable}.name`,
+        collectionVersion: `${collectionsTable}.version`,
+    })
+        .innerJoin(collectionsTable, `${granulesTable}.collection_cumulus_id`, `${collectionsTable}.cumulus_id`)
+        .leftJoin(providersTable, `${granulesTable}.provider_cumulus_id`, `${providersTable}.cumulus_id`)
+        .modify((queryBuilder) => {
+        if (collectionIds) {
+            const collectionIdFilters = [collectionIds].flat();
+            const collectionIdConcatField = `(${collectionsTable}.name || '${Collections_1.collectionIdSeparator}' || ${collectionsTable}.version)`;
+            const collectionIdInClause = collectionIdFilters.map(() => '?').join(',');
+            queryBuilder.whereRaw(`${collectionIdConcatField} IN (${collectionIdInClause})`, collectionIdFilters);
+        }
+        if (granuleIds) {
+            const granuleIdFilters = [granuleIds].flat();
+            queryBuilder.where((nestedQueryBuilder) => {
+                granuleIdFilters.forEach((granuleId) => {
+                    nestedQueryBuilder.orWhere(`${granulesTable}.granule_id`, 'LIKE', `%${granuleId}%`);
+                });
+            });
+        }
+        if (providerNames) {
+            queryBuilder.whereIn(`${providersTable}.name`, providerNames);
+        }
+        if (updatedAtRange.updatedAtFrom) {
+            queryBuilder.where(`${granulesTable}.updated_at`, '>=', updatedAtRange.updatedAtFrom);
+        }
+        if (updatedAtRange.updatedAtTo) {
+            queryBuilder.where(`${granulesTable}.updated_at`, '<=', updatedAtRange.updatedAtTo);
+        }
+        if (status) {
+            queryBuilder.where(`${granulesTable}.status`, status);
+        }
+        if (sortByFields) {
+            queryBuilder.orderBy([sortByFields].flat());
+        }
+    })
+        .groupBy(`${granulesTable}.cumulus_id`)
+        .groupBy(`${collectionsTable}.cumulus_id`)
+        .groupBy(`${providersTable}.cumulus_id`);
+};
+exports.getGranulesByApiPropertiesQuery = getGranulesByApiPropertiesQuery;
 //# sourceMappingURL=granule.js.map

package/dist/migrations/{20220126172008_files_granule_id_index.d.ts → 20210914051414_add_type_to_files.d.ts}

@@ -1,4 +1,4 @@
 import { Knex } from 'knex';
 export declare const up: (knex: Knex) => Promise<void>;
 export declare const down: (knex: Knex) => Promise<void>;
-//# sourceMappingURL=20220126172008_files_granule_id_index.d.ts.map
+//# sourceMappingURL=20210914051414_add_type_to_files.d.ts.map

package/dist/migrations/{20220126172008_files_granule_id_index.js → 20210914051414_add_type_to_files.js}

@@ -3,14 +3,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.down = exports.up = void 0;
 const up = async (knex) => {
     await knex.schema.table('files', (table) => {
-        table.index('granule_cumulus_id');
+        table
+            .text('type')
+            .comment('file "type"');
     });
 };
 exports.up = up;
 const down = async (knex) => {
     await knex.schema.table('files', (table) => {
-        table.dropIndex('granule_cumulus_id');
+        table.dropColumn('type');
     });
 };
 exports.down = down;
-//# sourceMappingURL=20220126172008_files_granule_id_index.js.map
+//# sourceMappingURL=20210914051414_add_type_to_files.js.map

package/dist/models/base.d.ts

@@ -1,12 +1,21 @@
 import { Knex } from 'knex';
+import { UpdatedAtRange } from '../types/record';
+import { BaseRecord } from '../types/base';
 import { TableNames } from '../tables';
-declare class BasePgModel<ItemType, RecordType extends {
-    cumulus_id: number;
-}> {
+declare class BasePgModel<ItemType, RecordType extends BaseRecord> {
     readonly tableName: TableNames;
     constructor({ tableName, }: {
         tableName: TableNames;
     });
+    /**
+     * Fetches multiple items from Postgres
+     *
+     * @param {Knex | Knex.Transaction} knexOrTransaction - DB client or transaction
+     * @param {Partial<RecordType>} params - An object or any portion of an object of type RecordType
+     * @param {UpdatedAtRange} updatedAtParams - An object with Date search bounds for updatedAt
+     * @returns {Promise<PostgresCollectionRecord[]>} List of returned records
+     */
+    searchWithUpdatedAtRange(knexOrTransaction: Knex | Knex.Transaction, params: Partial<RecordType>, updatedAtParams: UpdatedAtRange): Promise<RecordType[]>;
     count(knexOrTransaction: Knex | Knex.Transaction, params: ([string, string, string] | [Partial<RecordType>])[]): Promise<{
         [k: string]: string | number;
     }[]>;
@@ -18,11 +27,13 @@ declare class BasePgModel<ItemType, RecordType extends {
      * @returns {Promise<RecordType>} The returned record
      */
     get(knexOrTransaction: Knex | Knex.Transaction, params: Partial<RecordType>): Promise<RecordType>;
+    getMaxCumulusId(knexOrTransaction: Knex | Knex.Transaction): Promise<number>;
+    paginateByCumulusId(knexOrTransaction: Knex | Knex.Transaction, startId?: number, pageSize?: number): Promise<RecordType[]>;
     /**
      * Fetches multiple items from Postgres
      *
      * @param {Knex | Knex.Transaction} knexOrTransaction - DB client or transaction
-     * @param {Object} params - An object or any portion of an object of type RecordType
+     * @param {Partial<RecordType>} params - An object or any portion of an object of type RecordType
      * @returns {Promise<RecordType[]>} List of returned records
      */
     search(knexOrTransaction: Knex | Knex.Transaction, params: Partial<RecordType>): Promise<RecordType[]>;
@@ -39,11 +50,11 @@ declare class BasePgModel<ItemType, RecordType extends {
     /**
      * Get cumulus_id column value for multiple records in Postgres
      *
-     * @param {Knex | Knex.Transaction} knexOrTransaction -
+     * @param {Knex | Knex.Transaction} knexOrTransaction
      *  DB client or transaction
      * @param {Array<string>} columnNames - column names for whereIn query
-     * @param {Array<string>} values - record values for whereIn query
-     * @returns {Promise<Array<number>>} An array of cumulus_ids for the returned records
+     * @param {Array<any>} values - record values for whereIn query
+     * @returns {Promise<Array>} An array of cumulus_ids for the returned records
      */
     getRecordsCumulusIds(knexOrTransaction: Knex | Knex.Transaction, columnNames: Array<keyof RecordType>, values: Array<any>): Promise<Array<number>>;
     /**
@@ -59,9 +70,23 @@ declare class BasePgModel<ItemType, RecordType extends {
      *
      * @param {Knex | Knex.Transaction} knexOrTransaction - DB client or transaction
      * @param {ItemType} item - A record to insert into the DB
-     * @returns {Promise<number[]>} List of IDs of the inserted records
+     * @param {string | Array<string>} returningFields - A string or array of strings
+     *   of columns to return. Defaults to 'cumulus_id'.
+     * @returns {Promise<unknown[] | Object[]>} Returns an array of objects or an
+     *   array of values from the specified column(s) from returningFields.
+     */
+    create(knexOrTransaction: Knex | Knex.Transaction, item: ItemType, returningFields?: string | string[]): Promise<unknown[] | Object[]>;
+    /**
+     * Creates multiple items in Postgres
+     *
+     * @param {Knex | Knex.Transaction} knexOrTransaction - DB client or transaction
+     * @param {ItemType[]} items - Records to insert into the DB
+     * @param {string | Array<string>} returningFields - A string or array of strings
+     *   of columns to return. Defaults to 'cumulus_id'.
+     * @returns {Promise<unknown[] | Object[]>} Returns an array of objects or an
+     *   array of values from the specified column(s) from returningFields.
      */
-    create(knexOrTransaction: Knex | Knex.Transaction, item: ItemType): Promise<number[]>;
+    insert(knexOrTransaction: Knex | Knex.Transaction, items: ItemType[], returningFields?: string | string[]): Promise<unknown[] | Object[]>;
     /**
      * Deletes the item from Postgres
      *
@@ -80,6 +105,21 @@ declare class BasePgModel<ItemType, RecordType extends {
      * @returns {Promise<RecordType[]>} List of returned records
      */
     update(knexOrTransaction: Knex | Knex.Transaction, whereClause: Partial<RecordType>, updateParams: Partial<RecordType>, returning?: Array<string>): Promise<any[]>;
+    /**
+    * Deletes items from postgres based on params, excluding any cumulus_ids in the excludeCumulusIds
+    * @param {Object} params
+    * @param {Knex | Knex.Transaction} params.knexOrTransaction - DB client or transaction
+    * @param {Partial<RecordType>} params.queryParams - An object or any portion
+    *                                             of an object of type RecordType
+    * @param {[number]} params.excludeCumulusIds - A list of cumulus_ids to exclude from the deletion
+    *                                       request
+    * @returns {Promise<number>} The number of rows deleted
+    */
+    deleteExcluding({ knexOrTransaction, excludeCumulusIds, queryParams, }: {
+        knexOrTransaction: Knex | Knex.Transaction;
+        excludeCumulusIds: Number[];
+        queryParams: Partial<RecordType>;
+    }): Promise<number>;
 }
 export { BasePgModel };
 //# sourceMappingURL=base.d.ts.map

package/dist/models/base.js

@@ -7,6 +7,28 @@ class BasePgModel {
     constructor({ tableName, }) {
         this.tableName = tableName;
     }
+    /**
+     * Fetches multiple items from Postgres
+     *
+     * @param {Knex | Knex.Transaction} knexOrTransaction - DB client or transaction
+     * @param {Partial<RecordType>} params - An object or any portion of an object of type RecordType
+     * @param {UpdatedAtRange} updatedAtParams - An object with Date search bounds for updatedAt
+     * @returns {Promise<PostgresCollectionRecord[]>} List of returned records
+     */
+    async searchWithUpdatedAtRange(knexOrTransaction, params, updatedAtParams) {
+        const records = await knexOrTransaction(this.tableName)
+            .where((builder) => {
+            var _a, _b;
+            builder.where(params);
+            if (updatedAtParams.updatedAtFrom || updatedAtParams.updatedAtTo) {
+                builder.whereBetween('updated_at', [
+                    (_a = updatedAtParams === null || updatedAtParams === void 0 ? void 0 : updatedAtParams.updatedAtFrom) !== null && _a !== void 0 ? _a : new Date(0),
+                    (_b = updatedAtParams === null || updatedAtParams === void 0 ? void 0 : updatedAtParams.updatedAtTo) !== null && _b !== void 0 ? _b : new Date(),
+                ]);
+            }
+        });
+        return records;
+    }
     async count(knexOrTransaction, params) {
         const query = knexOrTransaction(this.tableName).where((builder) => {
             params.forEach((param) => {
@@ -36,11 +58,23 @@ class BasePgModel {
         }
         return record;
     }
+    async getMaxCumulusId(knexOrTransaction) {
+        const result = await knexOrTransaction(this.tableName).max('cumulus_id').first();
+        if (!result) {
+            throw new Error(`Invalid .max "cumulus_id" query on ${this.tableName}, MAX cumulus_id cannot be returned`);
+        }
+        return Number(result.max);
+    }
+    async paginateByCumulusId(knexOrTransaction, startId = 0, pageSize = 100) {
+        return await knexOrTransaction.select()
+            .from(this.tableName)
+            .whereBetween('cumulus_id', [startId, startId + pageSize - 1]);
+    }
     /**
      * Fetches multiple items from Postgres
      *
      * @param {Knex | Knex.Transaction} knexOrTransaction - DB client or transaction
-     * @param {Object} params - An object or any portion of an object of type RecordType
+     * @param {Partial<RecordType>} params - An object or any portion of an object of type RecordType
      * @returns {Promise<RecordType[]>} List of returned records
      */
     async search(knexOrTransaction, params) {
@@ -70,11 +104,11 @@ class BasePgModel {
     /**
      * Get cumulus_id column value for multiple records in Postgres
      *
-     * @param {Knex | Knex.Transaction} knexOrTransaction -
+     * @param {Knex | Knex.Transaction} knexOrTransaction
      *  DB client or transaction
      * @param {Array<string>} columnNames - column names for whereIn query
-     * @param {Array<string>} values - record values for whereIn query
-     * @returns {Promise<Array<number>>} An array of cumulus_ids for the returned records
+     * @param {Array<any>} values - record values for whereIn query
+     * @returns {Promise<Array>} An array of cumulus_ids for the returned records
      */
     async getRecordsCumulusIds(knexOrTransaction, columnNames, values) {
         const records = await knexOrTransaction(this.tableName)
@@ -106,12 +140,30 @@ class BasePgModel {
      *
      * @param {Knex | Knex.Transaction} knexOrTransaction - DB client or transaction
      * @param {ItemType} item - A record to insert into the DB
-     * @returns {Promise<number[]>} List of IDs of the inserted records
+     * @param {string | Array<string>} returningFields - A string or array of strings
+     *   of columns to return. Defaults to 'cumulus_id'.
+     * @returns {Promise<unknown[] | Object[]>} Returns an array of objects or an
+     *   array of values from the specified column(s) from returningFields.
      */
-    async create(knexOrTransaction, item) {
+    async create(knexOrTransaction, item, returningFields = 'cumulus_id') {
         return await knexOrTransaction(this.tableName)
             .insert(item)
-            .returning('cumulus_id');
+            .returning(returningFields);
+    }
+    /**
+     * Creates multiple items in Postgres
+     *
+     * @param {Knex | Knex.Transaction} knexOrTransaction - DB client or transaction
+     * @param {ItemType[]} items - Records to insert into the DB
+     * @param {string | Array<string>} returningFields - A string or array of strings
+     *   of columns to return. Defaults to 'cumulus_id'.
+     * @returns {Promise<unknown[] | Object[]>} Returns an array of objects or an
+     *   array of values from the specified column(s) from returningFields.
+     */
+    async insert(knexOrTransaction, items, returningFields = 'cumulus_id') {
+        return await knexOrTransaction(this.tableName)
+            .insert(items)
+            .returning(returningFields);
     }
     /**
      * Deletes the item from Postgres
@@ -139,6 +191,22 @@ class BasePgModel {
             .where(whereClause)
             .update(updateParams, returning);
     }
+    /**
+    * Deletes items from postgres based on params, excluding any cumulus_ids in the excludeCumulusIds
+    * @param {Object} params
+    * @param {Knex | Knex.Transaction} params.knexOrTransaction - DB client or transaction
+    * @param {Partial<RecordType>} params.queryParams - An object or any portion
+    *                                             of an object of type RecordType
+    * @param {[number]} params.excludeCumulusIds - A list of cumulus_ids to exclude from the deletion
+    *                                       request
+    * @returns {Promise<number>} The number of rows deleted
+    */
+    async deleteExcluding({ knexOrTransaction, excludeCumulusIds = [], queryParams, }) {
+        return await knexOrTransaction(this.tableName)
+            .where(queryParams)
+            .whereNotIn('cumulus_id', excludeCumulusIds)
+            .del();
+    }
 }
 exports.BasePgModel = BasePgModel;
 //# sourceMappingURL=base.js.map

package/dist/models/collection.d.ts

@@ -3,12 +3,13 @@ import { BasePgModel } from './base';
 import { PostgresCollection, PostgresCollectionRecord } from '../types/collection';
 declare class CollectionPgModel extends BasePgModel<PostgresCollection, PostgresCollectionRecord> {
     constructor();
+    create(knexOrTransaction: Knex | Knex.Transaction, item: PostgresCollection): Promise<Object[] | unknown[]>;
     upsert(knexOrTransaction: Knex | Knex.Transaction, collection: PostgresCollection): Knex.QueryBuilder<any, {
         _base: any;
-        _hasSelection: true;
-        _keys: "name" | "version" | "cumulus_id";
+        _hasSelection: false;
+        _keys: never;
         _aliases: {};
-        _single: true;
+        _single: false;
         _intersectProps: {};
         _unionProps: never;
     }[]>;

package/dist/models/collection.js

@@ -9,12 +9,15 @@ class CollectionPgModel extends base_1.BasePgModel {
             tableName: tables_1.TableNames.collections,
         });
     }
+    create(knexOrTransaction, item) {
+        return super.create(knexOrTransaction, item, '*');
+    }
     upsert(knexOrTransaction, collection) {
         return knexOrTransaction(this.tableName)
             .insert(collection)
             .onConflict(['name', 'version'])
             .merge()
-            .returning('cumulus_id');
+            .returning('*');
     }
 }
 exports.CollectionPgModel = CollectionPgModel;

package/dist/models/execution.d.ts

@@ -3,6 +3,7 @@ import { BasePgModel } from './base';
 import { PostgresExecution, PostgresExecutionRecord } from '../types/execution';
 declare class ExecutionPgModel extends BasePgModel<PostgresExecution, PostgresExecutionRecord> {
     constructor();
+    create(knexOrTransaction: Knex | Knex.Transaction, item: PostgresExecution): Promise<Object[] | unknown[]>;
     upsert(knexOrTrx: Knex | Knex.Transaction, execution: PostgresExecution): Promise<any[]>;
     /**
      * Get executions from the execution cumulus_id

package/dist/models/execution.js

@@ -10,6 +10,9 @@ class ExecutionPgModel extends base_1.BasePgModel {
             tableName: tables_1.TableNames.executions,
         });
     }
+    create(knexOrTransaction, item) {
+        return super.create(knexOrTransaction, item, '*');
+    }
     async upsert(knexOrTrx, execution) {
         if (execution.status === 'running') {
             return await knexOrTrx(this.tableName)
@@ -21,13 +24,13 @@ class ExecutionPgModel extends base_1.BasePgModel {
                 timestamp: execution.timestamp,
                 original_payload: execution.original_payload,
             })
-                .returning('cumulus_id');
+                .returning('*');
         }
         return await knexOrTrx(this.tableName)
             .insert(execution)
             .onConflict('arn')
             .merge()
-            .returning('cumulus_id');
+            .returning('*');
     }
     /**
      * Get executions from the execution cumulus_id

package/dist/models/file.d.ts

@@ -5,8 +5,8 @@ declare class FilePgModel extends BasePgModel<PostgresFile, PostgresFileRecord>
     constructor();
     upsert(knexOrTrx: Knex | Knex.Transaction, file: PostgresFile): Knex.QueryBuilder<any, {
         _base: any;
-        _hasSelection: true;
-        _keys: "key" | "bucket";
+        _hasSelection: false;
+        _keys: never;
         _aliases: {};
         _single: false;
         _intersectProps: {};

package/dist/models/file.js

@@ -13,7 +13,8 @@ class FilePgModel extends base_1.BasePgModel {
         return knexOrTrx(this.tableName)
             .insert(file)
             .onConflict(['bucket', 'key'])
-            .merge();
+            .merge()
+            .returning('*');
     }
 }
 exports.FilePgModel = FilePgModel;

package/dist/models/granule.d.ts

@@ -7,6 +7,7 @@ interface RecordSelect {
 }
 export default class GranulePgModel extends BasePgModel<PostgresGranule, PostgresGranuleRecord> {
     constructor();
+    create(knexOrTransaction: Knex | Knex.Transaction, item: PostgresGranule): Promise<Object[] | unknown[]>;
     /**
      * Deletes the item from Postgres
      *
@@ -17,6 +18,7 @@ export default class GranulePgModel extends BasePgModel<PostgresGranule, Postgre
     delete(knexOrTransaction: Knex | Knex.Transaction, params: PostgresGranuleUniqueColumns | {
         cumulus_id: number;
     }): Promise<number>;
+    deleteExcluding(): Promise<never>;
     /**
      * Checks if a granule is present in PostgreSQL
      *

package/dist/models/granule.js

@@ -16,6 +16,9 @@ class GranulePgModel extends base_1.BasePgModel {
             tableName: tables_1.TableNames.granules,
         });
     }
+    create(knexOrTransaction, item) {
+        return super.create(knexOrTransaction, item, '*');
+    }
     /**
      * Deletes the item from Postgres
      *
@@ -28,6 +31,9 @@ class GranulePgModel extends base_1.BasePgModel {
             .where(params)
             .del();
     }
+    async deleteExcluding() {
+        throw new Error('deleteExcluding not implemented on granule class');
+    }
     /**
      * Checks if a granule is present in PostgreSQL
      *
@@ -88,7 +94,7 @@ class GranulePgModel extends base_1.BasePgModel {
                 // will not affect any rows.
                 upsertQuery.whereNotExists(granulesExecutionsPgModel.search(knexOrTrx, { execution_cumulus_id: executionCumulusId }));
             }
-            upsertQuery.returning('cumulus_id');
+            upsertQuery.returning('*');
             return await upsertQuery;
         }
         return await knexOrTrx(this.tableName)
@@ -96,7 +102,7 @@ class GranulePgModel extends base_1.BasePgModel {
             .onConflict(['granule_id', 'collection_cumulus_id'])
             .merge()
             .where(knexOrTrx.raw(`${this.tableName}.created_at <= to_timestamp(${(0, timestamp_1.translateDateToUTC)(granule.created_at)})`))
-            .returning('cumulus_id');
+            .returning('*');
     }
     /**
      * Get granules from the granule cumulus_id

package/dist/models/pdr.js

@@ -26,14 +26,14 @@ class PdrPgModel extends base_1.BasePgModel {
                 qb.where(knexOrTrx.raw(`${this.tableName}.execution_cumulus_id != EXCLUDED.execution_cumulus_id`))
                     .orWhere(knexOrTrx.raw(`${this.tableName}.progress < EXCLUDED.progress`));
             })
-                .returning('cumulus_id');
+                .returning('*');
         }
         return await knexOrTrx(this.tableName)
             .insert(pdr)
             .onConflict('name')
             .merge()
             .where(knexOrTrx.raw(`${this.tableName}.created_at <= to_timestamp(${(0, timestamp_1.translateDateToUTC)(pdr.created_at)})`))
-            .returning('cumulus_id');
+            .returning('*');
     }
 }
 exports.default = PdrPgModel;

package/dist/test-utils.js

@@ -58,6 +58,9 @@ const fakeCollectionRecordFactory = (params) => ({
             regex: 'fake-regex',
             sampleFileName: 'file.txt',
         }]),
+    meta: { foo: 'bar' },
+    created_at: new Date(),
+    updated_at: new Date(),
     ...params,
 });
 exports.fakeCollectionRecordFactory = fakeCollectionRecordFactory;

package/dist/translate/async_operations.d.ts

@@ -1,4 +1,17 @@
 import { ApiAsyncOperation } from '@cumulus/types/api/async_operations';
 import { PostgresAsyncOperation } from '../types/async_operation';
+/**
+ * Generate a PostgreSQL Async Operation record from an API record.
+ *
+ * @param {Object} record - An API Async Operation record
+ * @returns {Object} A PostgreSQL Async Operation record
+ */
 export declare const translateApiAsyncOperationToPostgresAsyncOperation: (record: ApiAsyncOperation) => PostgresAsyncOperation;
+/**
+ * Generate an API Async Operation record from a PostgreSQL record.
+ *
+ * @param {Object} pgAsyncOperation - A PostgreSQL async operation record
+ * @returns {Object} An Async Operation API record
+ */
+export declare const translatePostgresAsyncOperationToApiAsyncOperation: (pgAsyncOperation: PostgresAsyncOperation) => ApiAsyncOperation;
 //# sourceMappingURL=async_operations.d.ts.map