How to refactor this function in my lambda? I have a loop in my function.

Question

Hello,

I am using a lambda function with amazon textract services and I have this function which I just saw something wrong that I did:

```
export async function startExpenseAnalysis(fileObj: FileObj): Promise {
  try {
    const command = new StartExpenseAnalysisCommand({
      DocumentLocation: {
        S3Object: {
          Bucket: fileObj.s3.bucket.name,
          Name: fileObj.s3.object.key,
        },
      },
    });
    const response = await textractClient.send(command);
    return response.JobId;
  } catch (error) {
    console.error(
      `Error starting expense analysis for object ${fileObj.s3.object.key} from bucket ${fileObj.s3.bucket.name}:`,
      error
    );
    throw error;
  }
}

export async function waitForCompletionAndDeleteMessage(
  jobId: string,
  receiptHandle: string
): Promise {
  let data;
  while (!data || data.JobStatus !== "SUCCEEDED") {
    const command = new GetExpenseAnalysisCommand({ JobId: jobId });
    data = await textractClient.send(command);
    console.log(data.JobStatus);
    if (data.JobStatus !== "SUCCEEDED") {
      // await new Promise((resolve) => setTimeout(resolve, 12000000));
      await new Promise((resolve) => setTimeout(resolve, 5000));
    }
  }
  await deleteMessageFromQueue(receiptHandle);
  return data;
}
```

At first it worked well, because I was just testing with one request at time, but if there are more than one request, if one request takes a long time, or get stuck in the while, there wont be new request as the first one will be there using it.

How should I use GetExpenseAnalysisCommand when I know the Job is finished?

I tried looking on my own, and found some possible solutions, adding a timeout or number of retries or using a poll service  but I am not sure.

- UPDATE:
Hello, I solved the issue following this: https://docs.aws.amazon.com/textract/latest/dg/api-async-roles.html. The problem I had that Amazon Textract wasn't publishing any messages to the SNS was related to permissions, trust relationships.

Accepted Answer

Not sure what exactly is the problem. You start an analysis operation, you get back a jobId and then you use it to poll the Textract service. If you have more thn one command running at a time, they should not affect each other.

BTW, you may consider moving to asynchronous, i.e., start the analysis in one function and then use the SNS Notification channel to invoke a different function when the operation finishes. This way you do not need to poll the service. This works only if there is no client waiting for the response from the first function of course.

Answer

Hello,

I was trying to add the SNS Notification channel that is in the following function:

```
    const command = new StartExpenseAnalysisCommand({
      DocumentLocation: {
        S3Object: {
          Bucket: fileObj.s3.bucket.name,
          Name: fileObj.s3.object.key,
        },
      },
      NotificationChannel: {
        SNSTopicArn: process.env.SNS_TOPIC_ARN,
        RoleArn: process.env.ROLE_ARN || undefined,
      },
    });
```

And I have defined in my serverless.yml the following:

```
provider:
......
  iam:
    role:
      statements:
        - Effect: Allow
          Action:
            - sqs:SendMessage
            - sqs:ReceiveMessage
            - sqs:DeleteMessage
          Resource: !GetAtt MySQSQueue.Arn
        - Effect: Allow
          Action:
            - textract:StartExpenseAnalysis
            - textract:GetExpenseAnalysis
          Resource: "*"
        - Effect: Allow
          Action:
            - s3:GetObject
            - s3:PutObject
          Resource: "*"
        - Effect: Allow
          Action:
            - sns:Publish
          Resource: !GetAtt TextractCompletionTopic.TopicArn
        - Effect: Allow
          Action:
            - lambda:InvokeFunction
          Resource: "*"
functions:
  startExpenseAnalysisJob:
    handler: src/functions/startExpenseAnalysisJob.handler
    timeout: 180
    maximumRetryAttempts: 0
    events:
      - sqs:
          arn: !GetAtt MySQSQueue.Arn
          batchSize: 1
  processExpenseAnalysisJob:
    handler: src/functions/processExpenseAnalysisJob.handler
    events:
      - sns:
          arn: !GetAtt TextractCompletionTopic.TopicArn
          topicName: TextractCompletionTopic-${self:provider.stage}
resources:
  Resources:
    TextractCompletionTopic:
      Type: AWS::SNS::Topic
      Properties:
        TopicName: TextractCompletionTopic-${self:provider.stage}
......
```

But the trigger to the lambda function processExpenseAnalysisJob, it is not receiving any sns messages or subscriptions, if I  publish a message directly from the AWS console SNS it does trigger the event, but just  using this part to post the is not working(The trigger to the lambda function):

```
      NotificationChannel: {
        SNSTopicArn: process.env.SNS_TOPIC_ARN,
        RoleArn: process.env.ROLE_ARN || undefined,
      },

```
As I read in the docs: https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-textract/Interface/StartExpenseAnalysisRequest/, where for NotificationChannel it describes it as: "The Amazon SNS topic ARN that you want Amazon Textract to publish the completion status of the operation to".

Please help :(

How to refactor this function in my lambda? I have a loop in my function.

Relevant content