@cumulus/db 10.1.1-alpha.0 → 10.1.3

package/dist/lib/granule.js

@@ -1,22 +1,10 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-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"));
+exports.getApiGranuleExecutionCumulusIds = exports.getApiGranuleCumulusIds = exports.upsertGranuleWithExecutionJoinRecord = void 0;
 const collection_1 = require("../models/collection");
 const granule_1 = require("../models/granule");
 const granules_executions_1 = require("../models/granules-executions");
-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;
+const { deconstructCollectionId } = require('@cumulus/message/Collections');
 /**
  * Upsert a granule and a record in the granules/executions join table.
  *
@@ -26,24 +14,24 @@ exports.getGranuleCollectionId = getGranuleCollectionId;
  * @param {Object} [granulePgModel] - Granule PG model class instance
  * @param {Object} [granulesExecutionsPgModel]
  *   Granules/executions PG model class instance
- * @returns {Promise<PostgresGranuleRecord[]>}
+ * @returns {Promise<number[]>}
  */
 const upsertGranuleWithExecutionJoinRecord = async (knexTransaction, granule, executionCumulusId, granulePgModel = new granule_1.GranulePgModel(), granulesExecutionsPgModel = new granules_executions_1.GranulesExecutionsPgModel()) => {
-    const [pgGranule] = await granulePgModel.upsert(knexTransaction, granule, executionCumulusId);
+    const [granuleCumulusId] = 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 (!pgGranule) {
+    if (!granuleCumulusId) {
         return [];
     }
     if (executionCumulusId) {
         await granulesExecutionsPgModel.upsert(knexTransaction, {
-            granule_cumulus_id: pgGranule.cumulus_id,
+            granule_cumulus_id: granuleCumulusId,
             execution_cumulus_id: executionCumulusId,
         });
     }
-    return [pgGranule];
+    return [granuleCumulusId];
 };
 exports.upsertGranuleWithExecutionJoinRecord = upsertGranuleWithExecutionJoinRecord;
 /**
@@ -62,7 +50,7 @@ const getApiGranuleCumulusIds = async (knexOrTransaction, granules, collectionPg
         const { collectionId } = granule;
         let collectionCumulusId = collectionMap[collectionId];
         if (!collectionCumulusId) {
-            const { name, version } = (0, Collections_1.deconstructCollectionId)(collectionId);
+            const { name, version } = deconstructCollectionId(collectionId);
             collectionCumulusId = await collectionPgModel.getRecordCumulusId(knexOrTransaction, { name, version });
             collectionMap[collectionId] = collectionCumulusId;
         }
@@ -74,30 +62,6 @@ 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
  *
@@ -117,64 +81,4 @@ 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 → 20220126172008_files_granule_id_index.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=20210914051414_add_type_to_files.d.ts.map
+//# sourceMappingURL=20220126172008_files_granule_id_index.d.ts.map

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

@@ -3,16 +3,14 @@ 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"');
+        table.index('granule_cumulus_id');
     });
 };
 exports.up = up;
 const down = async (knex) => {
     await knex.schema.table('files', (table) => {
-        table.dropColumn('type');
+        table.dropIndex('granule_cumulus_id');
     });
 };
 exports.down = down;
-//# sourceMappingURL=20210914051414_add_type_to_files.js.map
+//# sourceMappingURL=20220126172008_files_granule_id_index.js.map

package/dist/models/base.d.ts

@@ -1,21 +1,12 @@
 import { Knex } from 'knex';
-import { UpdatedAtRange } from '../types/record';
-import { BaseRecord } from '../types/base';
 import { TableNames } from '../tables';
-declare class BasePgModel<ItemType, RecordType extends BaseRecord> {
+declare class BasePgModel<ItemType, RecordType extends {
+    cumulus_id: number;
+}> {
     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;
     }[]>;
@@ -27,13 +18,11 @@ declare class BasePgModel<ItemType, RecordType extends BaseRecord> {
      * @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 {Partial<RecordType>} params - An object or any portion of an object of type RecordType
+     * @param {Object} 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[]>;
@@ -50,11 +39,11 @@ declare class BasePgModel<ItemType, RecordType extends BaseRecord> {
     /**
      * 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<any>} values - record values for whereIn query
-     * @returns {Promise<Array>} An array of cumulus_ids for the returned records
+     * @param {Array<string>} values - record values for whereIn query
+     * @returns {Promise<Array<number>>} An array of cumulus_ids for the returned records
      */
     getRecordsCumulusIds(knexOrTransaction: Knex | Knex.Transaction, columnNames: Array<keyof RecordType>, values: Array<any>): Promise<Array<number>>;
     /**
@@ -72,21 +61,9 @@ declare class BasePgModel<ItemType, RecordType extends BaseRecord> {
      * @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<unknown[] | Object[]>} Returns an array of objects or an
-     *   array of values from the specified column(s) from returningFields.
+     * @returns {Promise<number[]>} List of IDs of the inserted records
      */
-    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[]>;
+    create(knexOrTransaction: Knex | Knex.Transaction, item: ItemType, returningFields?: string | string[]): Promise<number[]>;
     /**
      * Deletes the item from Postgres
      *
@@ -105,21 +82,6 @@ declare class BasePgModel<ItemType, RecordType extends BaseRecord> {
      * @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,28 +7,6 @@ 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) => {
@@ -58,23 +36,11 @@ 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 {Partial<RecordType>} params - An object or any portion of an object of type RecordType
+     * @param {Object} params - An object or any portion of an object of type RecordType
      * @returns {Promise<RecordType[]>} List of returned records
      */
     async search(knexOrTransaction, params) {
@@ -104,11 +70,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<any>} values - record values for whereIn query
-     * @returns {Promise<Array>} An array of cumulus_ids for the returned records
+     * @param {Array<string>} values - record values for whereIn query
+     * @returns {Promise<Array<number>>} An array of cumulus_ids for the returned records
      */
     async getRecordsCumulusIds(knexOrTransaction, columnNames, values) {
         const records = await knexOrTransaction(this.tableName)
@@ -142,29 +108,13 @@ 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<unknown[] | Object[]>} Returns an array of objects or an
-     *   array of values from the specified column(s) from returningFields.
+     * @returns {Promise<number[]>} List of IDs of the inserted records
      */
     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
      *
@@ -191,22 +141,6 @@ 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,13 +3,12 @@ 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: false;
-        _keys: never;
+        _hasSelection: true;
+        _keys: "name" | "version" | "cumulus_id";
         _aliases: {};
-        _single: false;
+        _single: true;
         _intersectProps: {};
         _unionProps: never;
     }[]>;

package/dist/models/collection.js

@@ -9,15 +9,12 @@ 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('*');
+            .returning('cumulus_id');
     }
 }
 exports.CollectionPgModel = CollectionPgModel;

package/dist/models/execution.d.ts

@@ -3,7 +3,6 @@ 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,9 +10,6 @@ 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)
@@ -24,13 +21,13 @@ class ExecutionPgModel extends base_1.BasePgModel {
                 timestamp: execution.timestamp,
                 original_payload: execution.original_payload,
             })
-                .returning('*');
+                .returning('cumulus_id');
         }
         return await knexOrTrx(this.tableName)
             .insert(execution)
             .onConflict('arn')
             .merge()
-            .returning('*');
+            .returning('cumulus_id');
     }
     /**
      * 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: false;
-        _keys: never;
+        _hasSelection: true;
+        _keys: "key" | "bucket";
         _aliases: {};
         _single: false;
         _intersectProps: {};

package/dist/models/file.js

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

package/dist/models/granule.d.ts

@@ -7,7 +7,6 @@ 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
      *
@@ -18,7 +17,6 @@ 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,9 +16,6 @@ class GranulePgModel extends base_1.BasePgModel {
             tableName: tables_1.TableNames.granules,
         });
     }
-    create(knexOrTransaction, item) {
-        return super.create(knexOrTransaction, item, '*');
-    }
     /**
      * Deletes the item from Postgres
      *
@@ -31,9 +28,6 @@ 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
      *
@@ -94,7 +88,7 @@ class GranulePgModel extends base_1.BasePgModel {
                 // will not affect any rows.
                 upsertQuery.whereNotExists(granulesExecutionsPgModel.search(knexOrTrx, { execution_cumulus_id: executionCumulusId }));
             }
-            upsertQuery.returning('*');
+            upsertQuery.returning('cumulus_id');
             return await upsertQuery;
         }
         return await knexOrTrx(this.tableName)
@@ -102,7 +96,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('*');
+            .returning('cumulus_id');
     }
     /**
      * 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('*');
+                .returning('cumulus_id');
         }
         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('*');
+            .returning('cumulus_id');
     }
 }
 exports.default = PdrPgModel;

package/dist/test-utils.js

@@ -58,9 +58,6 @@ 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,17 +1,4 @@
 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