@cumulus/async-operations 19.0.0 → 19.2.0-alpha.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cumulus/async-operations",
-  "version": "19.0.0",
+  "version": "19.2.0-alpha.0",
   "description": "Cumulus Core internal async operations module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -32,19 +32,19 @@
   "dependencies": {
     "@aws-sdk/client-ecs": "^3.621.0",
     "@aws-sdk/client-lambda": "^3.621.0",
-    "@cumulus/aws-client": "19.0.0",
-    "@cumulus/db": "19.0.0",
-    "@cumulus/errors": "19.0.0",
-    "@cumulus/es-client": "19.0.0",
-    "@cumulus/logger": "19.0.0",
-    "@cumulus/types": "19.0.0",
+    "@cumulus/aws-client": "19.2.0-alpha.0",
+    "@cumulus/db": "19.2.0-alpha.0",
+    "@cumulus/errors": "19.2.0-alpha.0",
+    "@cumulus/es-client": "19.2.0-alpha.0",
+    "@cumulus/logger": "19.2.0-alpha.0",
+    "@cumulus/types": "19.2.0-alpha.0",
     "knex": "2.4.1",
     "uuid": "8.3.2"
   },
   "devDependencies": {
-    "@cumulus/common": "19.0.0",
+    "@cumulus/common": "19.2.0-alpha.0",
     "@types/aws-sdk": "2.7.0",
     "@types/uuid": "^8.0.0"
   },
-  "gitHead": "3a619db6e6fa20846eb75802e89d5a065fd62fcc"
+  "gitHead": "533280b62564b6ce89fabcde5cbe653afb964205"
 }

package/src/async_operations.ts

@@ -1,5 +1,4 @@
 import { RunTaskCommandOutput } from '@aws-sdk/client-ecs';
-import { Knex } from 'knex';
 import { FunctionConfiguration, GetFunctionConfigurationCommand } from '@aws-sdk/client-lambda';
 import { ecs, s3, lambda } from '@cumulus/aws-client/services';
 
@@ -8,7 +7,6 @@ import {
   translateApiAsyncOperationToPostgresAsyncOperation,
   translatePostgresAsyncOperationToApiAsyncOperation,
   AsyncOperationPgModel,
-  createRejectableTransaction,
 } from '@cumulus/db';
 import Logger from '@cumulus/logger';
 import { ApiAsyncOperation, AsyncOperationType } from '@cumulus/types/api/async_operations';
@@ -19,13 +17,6 @@ import type {
 } from './types';
 
 const { EcsStartTaskError, MissingRequiredArgument } = require('@cumulus/errors');
-const {
-  indexAsyncOperation,
-} = require('@cumulus/es-client/indexer');
-const {
-  getEsClient, EsClient,
-} = require('@cumulus/es-client/search');
-
 const logger = new Logger({ sender: '@cumulus/async-operation' });
 
 type StartEcsTaskReturnType = Promise<RunTaskCommandOutput>;
@@ -127,7 +118,6 @@ export const createAsyncOperation = async (
     stackName: string,
     systemBucket: string,
     knexConfig?: NodeJS.ProcessEnv,
-    esClient?: typeof EsClient,
     asyncOperationPgModel?: AsyncOperationPgModelObject
   }
 ): Promise<Partial<ApiAsyncOperation>> => {
@@ -136,7 +126,6 @@ export const createAsyncOperation = async (
     stackName,
     systemBucket,
     knexConfig = process.env,
-    esClient = await getEsClient(),
     asyncOperationPgModel = new AsyncOperationPgModel(),
   } = params;
 
@@ -144,14 +133,9 @@ export const createAsyncOperation = async (
   if (!systemBucket) throw new TypeError('systemBucket is required');
 
   const knex = await getKnexClient({ env: knexConfig });
-  return await createRejectableTransaction(knex, async (trx: Knex.Transaction) => {
-    const pgCreateObject = translateApiAsyncOperationToPostgresAsyncOperation(createObject);
-    const pgRecord = await asyncOperationPgModel.create(trx, pgCreateObject, ['*']);
-    const apiRecord = translatePostgresAsyncOperationToApiAsyncOperation(pgRecord[0]);
-    await indexAsyncOperation(esClient, apiRecord, process.env.ES_INDEX);
-
-    return apiRecord;
-  });
+  const pgCreateObject = translateApiAsyncOperationToPostgresAsyncOperation(createObject);
+  const pgRecord = await asyncOperationPgModel.create(knex, pgCreateObject, ['*']);
+  return translatePostgresAsyncOperationToApiAsyncOperation(pgRecord[0]);
 };
 
 /**

package/tests/test-async_operations.js

@@ -23,11 +23,6 @@ const {
   migrationDir,
 } = require('@cumulus/db');
 const { EcsStartTaskError, MissingRequiredArgument } = require('@cumulus/errors');
-const { Search } = require('@cumulus/es-client/search');
-const {
-  createTestIndex,
-  cleanupTestIndex,
-} = require('@cumulus/es-client/testUtils');
 const {
   getLambdaConfiguration,
   getLambdaEnvironmentVariables,
@@ -55,15 +50,6 @@ test.before(async (t) => {
   systemBucket = randomString();
   await s3().createBucket({ Bucket: systemBucket });
 
-  const { esIndex, esClient } = await createTestIndex();
-  t.context.esIndex = esIndex;
-  t.context.esClient = esClient;
-  t.context.esAsyncOperationsClient = new Search(
-    {},
-    'asyncOperation',
-    t.context.esIndex
-  );
-
   // Set up the mock ECS client
   ecsClient = ecs();
   ecsClient.runTask = (params) => {
@@ -103,7 +89,6 @@ test.beforeEach((t) => {
 test.after.always(async (t) => {
   sinon.restore();
   await recursivelyDeleteS3Bucket(systemBucket);
-  await cleanupTestIndex(t.context);
   await destroyLocalTestDb({
     knex: t.context.testKnex,
     knexAdmin: t.context.testKnexAdmin,
@@ -272,7 +257,7 @@ test.serial('The startAsyncOperation method throws error and calls createAsyncOp
   );
 });
 
-test('The startAsyncOperation writes records to all data stores', async (t) => {
+test('The startAsyncOperation writes records to the database', async (t) => {
   const description = randomString();
   const stackName = randomString();
   const operationType = 'ES Index';
@@ -312,51 +297,6 @@ test('The startAsyncOperation writes records to all data stores', async (t) => {
     omit(asyncOperationPgRecord, omitList),
     translateApiAsyncOperationToPostgresAsyncOperation(omit(expected, omitList))
   );
-  const esRecord = await t.context.esAsyncOperationsClient.get(id);
-  t.deepEqual(
-    await t.context.esAsyncOperationsClient.get(id),
-    {
-      ...expected,
-      _id: esRecord._id,
-      timestamp: esRecord.timestamp,
-      updatedAt: esRecord.updatedAt,
-      createdAt: esRecord.createdAt,
-    }
-  );
-});
-
-test.serial('The startAsyncOperation writes records with correct timestamps', async (t) => {
-  const description = randomString();
-  const stackName = randomString();
-  const operationType = 'ES Index';
-  const taskArn = randomString();
-
-  stubbedEcsRunTaskResult = {
-    tasks: [{ taskArn }],
-    failures: [],
-  };
-
-  const { id } = await startAsyncOperation({
-    asyncOperationTaskDefinition: randomString(),
-    cluster: randomString(),
-    callerLambdaName: randomString(),
-    lambdaName: randomString(),
-    description,
-    operationType,
-    payload: {},
-    stackName,
-    knexConfig: knexConfig,
-    systemBucket,
-  });
-
-  const asyncOperationPgRecord = await t.context.asyncOperationPgModel.get(
-    t.context.testKnex,
-    { id }
-  );
-
-  const esRecord = await t.context.esAsyncOperationsClient.get(id);
-  t.is(asyncOperationPgRecord.created_at.getTime(), esRecord.createdAt);
-  t.is(asyncOperationPgRecord.updated_at.getTime(), esRecord.updatedAt);
 });
 
 test.serial('The startAsyncOperation method returns the newly-generated record', async (t) => {
@@ -492,63 +432,3 @@ test('createAsyncOperation throws if systemBucket is not provided', async (t) =>
     { name: 'TypeError' }
   );
 });
-
-test.serial('createAsyncOperation() does not write to Elasticsearch if writing to PostgreSQL fails', async (t) => {
-  const { id, createObject } = t.context;
-
-  const fakeAsyncOpPgModel = {
-    create: () => {
-      throw new Error('something bad');
-    },
-  };
-
-  const createParams = {
-    knex: t.context.testKnex,
-    asyncOperationPgModel: fakeAsyncOpPgModel,
-    createObject,
-    stackName: 'FakeStack',
-    systemBucket: 'FakeBucket',
-  };
-  await t.throwsAsync(
-    createAsyncOperation(createParams),
-    { message: 'something bad' }
-  );
-
-  const dbRecords = await t.context.asyncOperationPgModel
-    .search(t.context.testKnex, { id });
-  t.is(dbRecords.length, 0);
-  t.false(await t.context.esAsyncOperationsClient.exists(
-    id
-  ));
-});
-
-test.serial('createAsyncOperation() does not write to PostgreSQL if writing to Elasticsearch fails', async (t) => {
-  const { id, createObject } = t.context;
-  const fakeEsClient = {
-    initializeEsClient: () => Promise.resolve(),
-    client: {
-      index: () => {
-        throw new Error('ES something bad');
-      },
-    },
-  };
-
-  const createParams = {
-    knex: t.context.testKnex,
-    createObject,
-    esClient: fakeEsClient,
-    stackName: 'FakeStack',
-    systemBucket: 'FakeBucket',
-  };
-  await t.throwsAsync(
-    createAsyncOperation(createParams),
-    { message: 'ES something bad' }
-  );
-
-  const dbRecords = await t.context.asyncOperationPgModel
-    .search(t.context.testKnex, { id });
-  t.is(dbRecords.length, 0);
-  t.false(await t.context.esAsyncOperationsClient.exists(
-    id
-  ));
-});