@event-driven-io/emmett-testcontainers 0.43.0-beta.4 → 0.43.0-beta.6

package/dist/index.js

@@ -35,29 +35,33 @@ var EmmettError = class _EmmettError extends Error {
 };
 
 // ../emmett/dist/index.js
-import { v4 as uuid4 } from "uuid";
+import { v4 as uuid5 } from "uuid";
+import { v7 as uuid2 } from "uuid";
 import { v7 as uuid } from "uuid";
 import retry from "async-retry";
-import { v7 as uuid2 } from "uuid";
-import { v4 as uuid3 } from "uuid";
-import { v7 as uuid5 } from "uuid";
+import { v7 as uuid3 } from "uuid";
+import { v4 as uuid4 } from "uuid";
+import { v7 as uuid6 } from "uuid";
 var emmettPrefix = "emt";
 var defaultTag = `${emmettPrefix}:default`;
 var unknownTag = `${emmettPrefix}:unknown`;
 var TaskProcessor = class {
-  constructor(options) {
-    this.options = options;
-  }
   queue = [];
   isProcessing = false;
   activeTasks = 0;
   activeGroups = /* @__PURE__ */ new Set();
+  options;
+  stopped = false;
+  constructor(options) {
+    this.options = options;
+  }
   enqueue(task, options) {
+    if (this.stopped) {
+      return Promise.reject(new EmmettError("TaskProcessor has been stopped"));
+    }
     if (this.queue.length >= this.options.maxQueueSize) {
       return Promise.reject(
-        new EmmettError(
-          "Too many pending connections. Please try again later."
-        )
+        new EmmettError("Too many pending tasks. Please try again later.")
       );
     }
     return this.schedule(task, options);
@@ -65,6 +69,15 @@ var TaskProcessor = class {
   waitForEndOfProcessing() {
     return this.schedule(({ ack }) => Promise.resolve(ack()));
   }
+  async stop(options) {
+    if (this.stopped) return;
+    this.stopped = true;
+    this.queue.length = 0;
+    this.activeGroups.clear();
+    if (!options?.force) {
+      await this.waitForEndOfProcessing();
+    }
+  }
   schedule(task, options) {
     return promiseWithDeadline(
       (resolve, reject) => {
@@ -143,22 +156,33 @@ var DEFAULT_PROMISE_DEADLINE = 2147483647;
 var promiseWithDeadline = (executor, options) => {
   return new Promise((resolve, reject) => {
     let taskStarted = false;
-    const maxWaitingTime = options.deadline || DEFAULT_PROMISE_DEADLINE;
-    let timeoutId = setTimeout(() => {
+    let timeoutId = null;
+    const deadline = options.deadline ?? DEFAULT_PROMISE_DEADLINE;
+    timeoutId = setTimeout(() => {
       if (!taskStarted) {
         reject(
           new Error("Task was not started within the maximum waiting time")
         );
       }
-    }, maxWaitingTime);
-    executor((value) => {
-      taskStarted = true;
-      if (timeoutId) {
-        clearTimeout(timeoutId);
+    }, deadline);
+    timeoutId.unref();
+    executor(
+      (value) => {
+        taskStarted = true;
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+        }
+        timeoutId = null;
+        resolve(value);
+      },
+      (reason) => {
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+        }
+        timeoutId = null;
+        reject(reason);
       }
-      timeoutId = null;
-      resolve(value);
-    }, reject);
+    );
   });
 };
 var InProcessLock = () => {