@event-driven-io/emmett-testcontainers 0.43.0-beta.1 → 0.43.0-beta.11

package/dist/index.cjs

@@ -37,26 +37,31 @@ var EmmettError = (_class = class _EmmettError extends Error {
 // ../emmett/dist/index.js
 var _uuid = require('uuid');
 
+
 var _asyncretry = require('async-retry'); var _asyncretry2 = _interopRequireDefault(_asyncretry);
 
 
+
 var emmettPrefix = "emt";
 var defaultTag = `${emmettPrefix}:default`;
 var unknownTag = `${emmettPrefix}:unknown`;
 var TaskProcessor = (_class2 = class {
-  constructor(options) {;_class2.prototype.__init.call(this);_class2.prototype.__init2.call(this);_class2.prototype.__init3.call(this);_class2.prototype.__init4.call(this);_class2.prototype.__init5.call(this);_class2.prototype.__init6.call(this);
-    this.options = options;
-  }
   __init() {this.queue = []}
   __init2() {this.isProcessing = false}
   __init3() {this.activeTasks = 0}
   __init4() {this.activeGroups = /* @__PURE__ */ new Set()}
+  
+  __init5() {this.stopped = false}
+  constructor(options) {;_class2.prototype.__init.call(this);_class2.prototype.__init2.call(this);_class2.prototype.__init3.call(this);_class2.prototype.__init4.call(this);_class2.prototype.__init5.call(this);_class2.prototype.__init6.call(this);_class2.prototype.__init7.call(this);
+    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);
@@ -64,6 +69,15 @@ var TaskProcessor = (_class2 = 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 (!_optionalChain([options, 'optionalAccess', _5 => _5.force])) {
+      await this.waitForEndOfProcessing();
+    }
+  }
   schedule(task, options) {
     return promiseWithDeadline(
       (resolve, reject) => {
@@ -96,16 +110,16 @@ var TaskProcessor = (_class2 = class {
       while (this.activeTasks < this.options.maxActiveTasks && this.queue.length > 0) {
         const item = this.takeFirstAvailableItem();
         if (item === null) return;
-        const groupId = _optionalChain([item, 'access', _5 => _5.options, 'optionalAccess', _6 => _6.taskGroupId]);
+        const groupId = _optionalChain([item, 'access', _6 => _6.options, 'optionalAccess', _7 => _7.taskGroupId]);
         if (groupId) {
           this.activeGroups.add(groupId);
         }
         this.activeTasks++;
         void this.executeItem(item);
       }
-    } catch (error2) {
-      console.error(error2);
-      throw error2;
+    } catch (error) {
+      console.error(error);
+      throw error;
     } finally {
       this.isProcessing = false;
       if (this.hasItemsToProcess() && this.activeTasks < this.options.maxActiveTasks) {
@@ -124,9 +138,9 @@ var TaskProcessor = (_class2 = class {
       this.ensureProcessing();
     }
   }
-  __init5() {this.takeFirstAvailableItem = () => {
+  __init6() {this.takeFirstAvailableItem = () => {
     const taskIndex = this.queue.findIndex(
-      (item2) => !_optionalChain([item2, 'access', _7 => _7.options, 'optionalAccess', _8 => _8.taskGroupId]) || !this.activeGroups.has(item2.options.taskGroupId)
+      (item2) => !_optionalChain([item2, 'access', _8 => _8.options, 'optionalAccess', _9 => _9.taskGroupId]) || !this.activeGroups.has(item2.options.taskGroupId)
     );
     if (taskIndex === -1) {
       return null;
@@ -134,30 +148,41 @@ var TaskProcessor = (_class2 = class {
     const [item] = this.queue.splice(taskIndex, 1);
     return _nullishCoalesce(item, () => ( null));
   }}
-  __init6() {this.hasItemsToProcess = () => this.queue.findIndex(
-    (item) => !_optionalChain([item, 'access', _9 => _9.options, 'optionalAccess', _10 => _10.taskGroupId]) || !this.activeGroups.has(item.options.taskGroupId)
+  __init7() {this.hasItemsToProcess = () => this.queue.findIndex(
+    (item) => !_optionalChain([item, 'access', _10 => _10.options, 'optionalAccess', _11 => _11.taskGroupId]) || !this.activeGroups.has(item.options.taskGroupId)
   ) !== -1}
 }, _class2);
 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 = _nullishCoalesce(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 = () => {
@@ -211,6 +236,109 @@ var InProcessLock = () => {
     }
   };
 };
+var bigIntReplacer = (_key, value) => {
+  return typeof value === "bigint" ? value.toString() : value;
+};
+var dateReplacer = (_key, value) => {
+  return value instanceof Date ? value.toISOString() : value;
+};
+var isFirstLetterNumeric = (str) => {
+  const c = str.charCodeAt(0);
+  return c >= 48 && c <= 57;
+};
+var isFirstLetterNumericOrMinus = (str) => {
+  const c = str.charCodeAt(0);
+  return c >= 48 && c <= 57 || c === 45;
+};
+var bigIntReviver = (_key, value, context) => {
+  if (typeof value === "number" && Number.isInteger(value) && !Number.isSafeInteger(value)) {
+    try {
+      return BigInt(_nullishCoalesce(_optionalChain([context, 'optionalAccess', _12 => _12.source]), () => ( value.toString())));
+    } catch (e) {
+      return value;
+    }
+  }
+  if (typeof value === "string" && value.length > 15) {
+    if (isFirstLetterNumericOrMinus(value)) {
+      const num = Number(value);
+      if (Number.isFinite(num) && !Number.isSafeInteger(num)) {
+        try {
+          return BigInt(value);
+        } catch (e2) {
+        }
+      }
+    }
+  }
+  return value;
+};
+var dateReviver = (_key, value) => {
+  if (typeof value === "string" && value.length === 24 && isFirstLetterNumeric(value) && value[10] === "T" && value[23] === "Z") {
+    const date = new Date(value);
+    if (!isNaN(date.getTime())) {
+      return date;
+    }
+  }
+  return value;
+};
+var composeJSONReplacers = (...replacers) => {
+  const filteredReplacers = replacers.filter((r) => r !== void 0);
+  if (filteredReplacers.length === 0) return void 0;
+  return (key, value) => (
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    filteredReplacers.reduce(
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+      (accValue, replacer) => replacer(key, accValue),
+      value
+    )
+  );
+};
+var composeJSONRevivers = (...revivers) => {
+  const filteredRevivers = revivers.filter((r) => r !== void 0);
+  if (filteredRevivers.length === 0) return void 0;
+  return (key, value, context) => (
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    filteredRevivers.reduce(
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+      (accValue, reviver) => reviver(key, accValue, context),
+      value
+    )
+  );
+};
+var JSONReplacer = (opts) => composeJSONReplacers(
+  _optionalChain([opts, 'optionalAccess', _13 => _13.replacer]),
+  _optionalChain([opts, 'optionalAccess', _14 => _14.failOnBigIntSerialization]) !== true ? JSONReplacers.bigInt : void 0,
+  _optionalChain([opts, 'optionalAccess', _15 => _15.useDefaultDateSerialization]) !== true ? JSONReplacers.date : void 0
+);
+var JSONReviver = (opts) => composeJSONRevivers(
+  _optionalChain([opts, 'optionalAccess', _16 => _16.reviver]),
+  _optionalChain([opts, 'optionalAccess', _17 => _17.parseBigInts]) === true ? JSONRevivers.bigInt : void 0,
+  _optionalChain([opts, 'optionalAccess', _18 => _18.parseDates]) === true ? JSONRevivers.date : void 0
+);
+var JSONReplacers = {
+  bigInt: bigIntReplacer,
+  date: dateReplacer
+};
+var JSONRevivers = {
+  bigInt: bigIntReviver,
+  date: dateReviver
+};
+var jsonSerializer = (options) => {
+  const defaultReplacer = JSONReplacer(options);
+  const defaultReviver = JSONReviver(options);
+  return {
+    serialize: (object, serializerOptions) => JSON.stringify(
+      object,
+      serializerOptions ? JSONReplacer(serializerOptions) : defaultReplacer
+    ),
+    deserialize: (payload, deserializerOptions) => JSON.parse(
+      payload,
+      deserializerOptions ? JSONReviver(deserializerOptions) : defaultReviver
+    )
+  };
+};
+var JSONSerializer = Object.assign(jsonSerializer(), {
+  from: (options) => _nullishCoalesce(_optionalChain([options, 'optionalAccess', _19 => _19.serialization, 'optionalAccess', _20 => _20.serializer]), () => ( (_optionalChain([options, 'optionalAccess', _21 => _21.serialization, 'optionalAccess', _22 => _22.options]) ? jsonSerializer(_optionalChain([options, 'optionalAccess', _23 => _23.serialization, 'optionalAccess', _24 => _24.options])) : JSONSerializer)))
+});
 var textEncoder = new TextEncoder();
 
 // src/eventStore/eventStoreDBContainer.ts
@@ -300,7 +428,7 @@ var releaseSharedEventStoreDBTestContainer = () => lock.withAcquire(
         startedContainer = null;
         container = null;
         await containerToStop.stop();
-      } catch (e) {
+      } catch (e3) {
       }
     }
   },