@cumulus/db 10.1.2 → 11.0.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/20210914051414_add_type_to_files.d.ts

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

package/dist/migrations/20210914051414_add_type_to_files.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.down = exports.up = void 0;
+const up = async (knex) => {
+    await knex.schema.table('files', (table) => {
+        table
+            .text('type')
+            .comment('file "type"');
+    });
+};
+exports.up = up;
+const down = async (knex) => {
+    await knex.schema.table('files', (table) => {
+        table.dropColumn('type');
+    });
+};
+exports.down = down;
+//# 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, }: {
+    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,6 +27,24 @@ 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[]>;
+    /**
+     * Builds query to fetch mulitple 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
+     * @returns {Object} - Knex querybuilder object
+     */
+    queryBuilderSearch(knexOrTransaction: Knex | Knex.Transaction, params: Partial<RecordType>): Knex.QueryBuilder<any, {
+        _base: any;
+        _hasSelection: false;
+        _keys: never;
+        _aliases: {};
+        _single: false;
+        _intersectProps: {};
+        _unionProps: never;
+    }[]>;
     /**
      * Fetches multiple items from Postgres
      *
@@ -39,11 +66,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>>;
     /**
@@ -61,9 +88,21 @@ declare class BasePgModel<ItemType, RecordType extends {
      * @param {ItemType} item - A record 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<number[]>} List of IDs of the inserted records
+     * @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<number[]>;
+    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.
+     */
+    insert(knexOrTransaction: Knex | Knex.Transaction, items: ItemType[], returningFields?: string | string[]): Promise<unknown[] | Object[]>;
     /**
      * Deletes the item from Postgres
      *
@@ -82,6 +121,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

@@ -4,11 +4,33 @@ exports.BasePgModel = void 0;
 const errors_1 = require("@cumulus/errors");
 const database_1 = require("../database");
 class BasePgModel {
-    constructor({ tableName, }) {
+    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) => {
+        const query = knexOrTransaction(this.tableName)
+            .where((builder) => {
             params.forEach((param) => {
                 if (param.length === 3) {
                     builder.where(...param);
@@ -17,7 +39,8 @@ class BasePgModel {
                     builder.where(param[0]);
                 }
             });
-        }).count();
+        })
+            .count();
         return await query;
     }
     /**
@@ -36,6 +59,31 @@ 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]);
+    }
+    /**
+     * Builds query to fetch mulitple 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
+     * @returns {Object} - Knex querybuilder object
+     */
+    queryBuilderSearch(knexOrTransaction, params) {
+        return knexOrTransaction(this.tableName).where(params);
+    }
     /**
      * Fetches multiple items from Postgres
      *
@@ -44,8 +92,7 @@ class BasePgModel {
      * @returns {Promise<RecordType[]>} List of returned records
      */
     async search(knexOrTransaction, params) {
-        const records = await knexOrTransaction(this.tableName)
-            .where(params);
+        const records = await this.queryBuilderSearch(knexOrTransaction, params);
         return records;
     }
     /**
@@ -70,11 +117,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)
@@ -108,13 +155,29 @@ class BasePgModel {
      * @param {ItemType} item - A record 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<number[]>} List of IDs of the inserted records
+     * @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, returningFields = 'cumulus_id') {
         return await knexOrTransaction(this.tableName)
             .insert(item)
             .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
      *
@@ -123,9 +186,7 @@ class BasePgModel {
      * @returns {Promise<number>} The number of rows deleted
      */
     async delete(knexOrTransaction, params) {
-        return await knexOrTransaction(this.tableName)
-            .where(params)
-            .del();
+        return await knexOrTransaction(this.tableName).where(params).del();
     }
     /**
      * Updates the item or items in Postgres
@@ -141,6 +202,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,8 @@ import { BasePgModel } from './base';
 import { PostgresExecution, PostgresExecutionRecord } from '../types/execution';
 declare class ExecutionPgModel extends BasePgModel<PostgresExecution, PostgresExecutionRecord> {
     constructor();
+    static nonActiveStatuses: string[];
+    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
@@ -64,4 +67,5 @@ class ExecutionPgModel extends base_1.BasePgModel {
     }
 }
 exports.ExecutionPgModel = ExecutionPgModel;
+ExecutionPgModel.nonActiveStatuses = ['completed', 'failed', 'unknown'];
 //# sourceMappingURL=execution.js.map

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

@@ -1,12 +1,13 @@
 import { Knex } from 'knex';
 import { PostgresGranule, PostgresGranuleRecord, PostgresGranuleUniqueColumns } from '../types/granule';
 import { BasePgModel } from './base';
-import { GranulesExecutionsPgModel } from './granules-executions';
+import { ExecutionPgModel } from './execution';
 interface RecordSelect {
     cumulus_id: number;
 }
 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
      *
@@ -35,7 +37,16 @@ export default class GranulePgModel extends BasePgModel<PostgresGranule, Postgre
      * @returns {Promise<PostgresGranuleRecord>} The returned record
      */
     get(knexOrTransaction: Knex | Knex.Transaction, params: PostgresGranuleUniqueColumns | RecordSelect): Promise<PostgresGranuleRecord>;
-    upsert(knexOrTrx: Knex | Knex.Transaction, granule: PostgresGranule, executionCumulusId?: number, granulesExecutionsPgModel?: GranulesExecutionsPgModel): Promise<any[]>;
+    _buildExclusionClause(executionPgModel: ExecutionPgModel, executionCumulusId: number, knexOrTrx: Knex | Knex.Transaction, status: 'queued' | 'running'): Knex.QueryBuilder<any, {
+        _base: any;
+        _hasSelection: false;
+        _keys: never;
+        _aliases: {};
+        _single: false;
+        _intersectProps: {};
+        _unionProps: never;
+    }[]>;
+    upsert(knexOrTrx: Knex | Knex.Transaction, granule: PostgresGranule, executionCumulusId?: number, executionPgModel?: ExecutionPgModel): Promise<any[]>;
     /**
      * Get granules from the granule cumulus_id
      *