prime-sdk 3.0.2 → 3.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prime-sdk",
-  "version": "3.0.2",
+  "version": "3.0.4",
   "description": "swiss army knife",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/external/aws/sqs/sqs.service.ts

@@ -63,4 +63,8 @@ export class Sqs implements IQueue {
 
     return await this.sendCommand(deleteCommand);
   }
+
+  destroyClient(): void {
+    this.client.destroy();
+  }
 }

package/src/lib/queue/interfaces/queue.interface.ts

@@ -5,6 +5,7 @@ export interface IQueue {
   receiveMessages(): Promise<ReceiveMessageResult>;
   receiveMessagesV2(): Promise<ReceiveMessageResult>;
   setup({ waitTimeSeconds, bulk, queueUrl, attributeNames }): void;
+  destroyClient(): void;
 }
 
 export const IQueue = Symbol('IQueue');

package/src/lib/queue/queue.ts

@@ -16,7 +16,15 @@ export class Queue {
 
   private context: IConsumer = null;
 
-  private inWork: boolean = false;
+  private processing: number = 0;
+
+  private readonly MAX_TIME_TO_WAIT_FOR_PROCESSING = 20000;
+
+  private stopped: boolean = false;
+
+  private abortController: AbortController = null;
+
+  private inWork: boolean = true;
 
   private waitTimeSeconds: number = 20;
 
@@ -40,6 +48,10 @@ export class Queue {
     this.waitTimeSeconds = waitTimeSeconds;
     this.attributeNames = attributeNames;
     this.version = version;
+    this.abortController = new AbortController();
+    this.stopped = false;
+    this.processing = 0;
+    this.inWork = true;
 
     this.broker.setup({
       waitTimeSeconds: this.waitTimeSeconds,
@@ -48,19 +60,24 @@ export class Queue {
       attributeNames: this.attributeNames,
     });
 
-    while (!this.inWork) {
+    while (this.inWork) {
       await this.run(version);
     }
   }
 
   async run(version: number) {
-    this.inWork = true;
-
-    const response = await this.receiveMessages(version);
+    this.processing += 1;
 
     try {
+      const response = await this.receiveMessages(version);
+      const messages = response.Messages;
+
+      if (!messages) {
+        return;
+      }
+
       if (this.bulk === 1) {
-        const message = response.Messages?.[0] || null;
+        const message = messages?.[0] || null;
 
         if (message) {
           await this.context.handleMessage(message);
@@ -68,20 +85,21 @@ export class Queue {
           await this.deleteMessage(message.ReceiptHandle);
         }
 
-        this.inWork = false;
-
         return;
       }
 
-      await this.context.handleMessage(response.Messages);
+      await this.context.handleMessage(messages);
 
-      response.Messages.forEach(async (message: Message) => {
-        await this.deleteMessage(message.ReceiptHandle);
-      });
+      await Promise.all(
+        messages.map((message: Message) =>
+          this.deleteMessage(message.ReceiptHandle),
+        ),
+      );
     } catch (error) {
       await this.context.handleError(error);
+    } finally {
+      this.processing -= 1;
     }
-    this.inWork = false;
   }
 
   async receiveMessages(version: number): Promise<ReceiveMessageResult> {
@@ -95,4 +113,26 @@ export class Queue {
   async deleteMessage(receiptHandle): Promise<unknown> {
     return await this.broker.deleteMessage(receiptHandle);
   }
+
+  async stop(): Promise<void> {
+    if (this.stopped) {
+      return;
+    }
+    const timeMax = new Date().getTime() + this.MAX_TIME_TO_WAIT_FOR_PROCESSING;
+
+    this.inWork = false;
+    this.stopped = true;
+    this.abortController?.abort();
+
+    while (this.processing > 0) {
+      const time = new Date().getTime();
+      if (time >= timeMax) break;
+      await this.sleep(500);
+    }
+    this.broker.destroyClient();
+  }
+
+  private sleep(ms: number) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
 }

package/.yarnrc.yml

@@ -1 +0,0 @@
-nodeLinker: node-modules