@event-driven-io/emmett 0.23.0-alpha.5 → 0.23.0-alpha.7

package/dist/index.js

@@ -17,18 +17,6 @@ import {
   parseDateFromUtcYYYYMMDD
 } from "./chunk-AEEEXE2R.js";
 
-// src/eventStore/eventStore.ts
-var canCreateEventStoreSession = (eventStore) => "withSession" in eventStore;
-var nulloSessionFactory = (eventStore) => ({
-  withSession: (callback) => {
-    const nulloSession = {
-      eventStore,
-      close: () => Promise.resolve()
-    };
-    return callback(nulloSession);
-  }
-});
-
 // src/typing/command.ts
 var command = (type, data, metadata) => {
   return {
@@ -94,6 +82,25 @@ var accept = () => {
   return { kind: "Accept" };
 };
 
+// src/eventStore/afterCommit/afterEventStoreCommitHandler.ts
+async function tryPublishMessagesAfterCommit(messages, options, context) {
+  if (options?.onAfterCommit === void 0) return false;
+  try {
+    await options?.onAfterCommit(messages, context);
+    return true;
+  } catch (error2) {
+    console.error(`Error in on after commit hook`, error2);
+    return false;
+  }
+}
+
+// src/eventStore/afterCommit/forwardToMessageBus.ts
+var forwardToMessageBus = (eventPublisher) => async (messages) => {
+  for (const message of messages) {
+    await eventPublisher.publish(message);
+  }
+};
+
 // src/eventStore/events/index.ts
 var GlobalStreamCaughtUpType = "__emt:GlobalStreamCaughtUp";
 var isGlobalStreamCaughtUp = (event2) => event2.type === GlobalStreamCaughtUpType;
@@ -104,6 +111,18 @@ var globalStreamCaughtUp = (data) => event(GlobalStreamCaughtUpType, data, {
 var isSubscriptionEvent = (event2) => isGlobalStreamCaughtUp(event2);
 var isNotInternalEvent = (event2) => !isGlobalStreamCaughtUp(event2);
 
+// src/eventStore/eventStore.ts
+var canCreateEventStoreSession = (eventStore) => "withSession" in eventStore;
+var nulloSessionFactory = (eventStore) => ({
+  withSession: (callback) => {
+    const nulloSession = {
+      eventStore,
+      close: () => Promise.resolve()
+    };
+    return callback(nulloSession);
+  }
+});
+
 // src/eventStore/expectedVersion.ts
 var STREAM_EXISTS = "STREAM_EXISTS";
 var STREAM_DOES_NOT_EXIST = "STREAM_DOES_NOT_EXIST";
@@ -257,7 +276,7 @@ var StreamingCoordinator = () => {
 
 // src/eventStore/inMemoryEventStore.ts
 var InMemoryEventStoreDefaultStreamVersion = 0n;
-var getInMemoryEventStore = () => {
+var getInMemoryEventStore = (eventStoreOptions) => {
   const streams = /* @__PURE__ */ new Map();
   const streamingCoordinator = StreamingCoordinator();
   const getAllEventsCount = () => {
@@ -325,6 +344,7 @@ var getInMemoryEventStore = () => {
         nextExpectedStreamVersion: positionOfLastEventInTheStream,
         createdNewStream: currentStreamVersion === InMemoryEventStoreDefaultStreamVersion
       };
+      await tryPublishMessagesAfterCommit(newEvents, eventStoreOptions?.hooks);
       return result;
     }
     //streamEvents: streamingCoordinator.stream,
@@ -371,6 +391,178 @@ var sum = (iterator) => {
   return sum2;
 };
 
+// src/taskProcessing/taskProcessor.ts
+var TaskProcessor = class {
+  constructor(options) {
+    this.options = options;
+  }
+  queue = [];
+  isProcessing = false;
+  activeTasks = 0;
+  activeGroups = /* @__PURE__ */ new Set();
+  enqueue(task, options) {
+    if (this.queue.length >= this.options.maxQueueSize) {
+      return Promise.reject(
+        new EmmettError(
+          "Too many pending connections. Please try again later."
+        )
+      );
+    }
+    return this.schedule(task, options);
+  }
+  waitForEndOfProcessing() {
+    return this.schedule(({ ack }) => Promise.resolve(ack()));
+  }
+  schedule(task, options) {
+    return promiseWithDeadline(
+      (resolve, reject) => {
+        const taskWithContext = () => {
+          return new Promise((resolveTask, failTask) => {
+            const taskPromise = task({
+              ack: resolveTask
+            });
+            taskPromise.then(resolve).catch((err) => {
+              failTask(err);
+              reject(err);
+            });
+          });
+        };
+        this.queue.push({ task: taskWithContext, options });
+        if (!this.isProcessing) {
+          this.ensureProcessing();
+        }
+      },
+      { deadline: this.options.maxTaskIdleTime }
+    );
+  }
+  ensureProcessing() {
+    if (this.isProcessing) return;
+    this.isProcessing = true;
+    this.processQueue();
+  }
+  processQueue() {
+    try {
+      while (this.activeTasks < this.options.maxActiveTasks && this.queue.length > 0) {
+        const item = this.takeFirstAvailableItem();
+        if (item === null) return;
+        const groupId = item.options?.taskGroupId;
+        if (groupId) {
+          this.activeGroups.add(groupId);
+        }
+        this.activeTasks++;
+        void this.executeItem(item);
+      }
+    } catch (error2) {
+      console.error(error2);
+      throw error2;
+    } finally {
+      this.isProcessing = false;
+      if (this.hasItemsToProcess() && this.activeTasks < this.options.maxActiveTasks) {
+        this.ensureProcessing();
+      }
+    }
+  }
+  async executeItem({ task, options }) {
+    try {
+      await task();
+    } finally {
+      this.activeTasks--;
+      if (options && options.taskGroupId) {
+        this.activeGroups.delete(options.taskGroupId);
+      }
+      this.ensureProcessing();
+    }
+  }
+  takeFirstAvailableItem = () => {
+    const taskIndex = this.queue.findIndex(
+      (item2) => !item2.options?.taskGroupId || !this.activeGroups.has(item2.options.taskGroupId)
+    );
+    if (taskIndex === -1) {
+      return null;
+    }
+    const [item] = this.queue.splice(taskIndex, 1);
+    return item ?? null;
+  };
+  hasItemsToProcess = () => this.queue.findIndex(
+    (item) => !item.options?.taskGroupId || !this.activeGroups.has(item.options.taskGroupId)
+  ) !== -1;
+};
+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(() => {
+      if (!taskStarted) {
+        reject(
+          new Error("Task was not started within the maximum waiting time")
+        );
+      }
+    }, maxWaitingTime);
+    executor((value) => {
+      taskStarted = true;
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+      timeoutId = null;
+      resolve(value);
+    }, reject);
+  });
+};
+
+// src/utils/locking/index.ts
+var InProcessLock = () => {
+  const taskProcessor = new TaskProcessor({
+    maxActiveTasks: Number.MAX_VALUE,
+    maxQueueSize: Number.MAX_VALUE
+  });
+  const locks = /* @__PURE__ */ new Map();
+  return {
+    async acquire({ lockId }) {
+      await new Promise((resolve, reject) => {
+        taskProcessor.enqueue(
+          ({ ack }) => {
+            locks.set(lockId, ack);
+            resolve();
+            return Promise.resolve();
+          },
+          { taskGroupId: lockId }
+        ).catch(reject);
+      });
+    },
+    async tryAcquire({ lockId }) {
+      if (locks.has(lockId)) {
+        return false;
+      }
+      await this.acquire({ lockId });
+      return true;
+    },
+    release({ lockId }) {
+      const ack = locks.get(lockId);
+      if (ack === void 0) {
+        return Promise.resolve(true);
+      }
+      locks.delete(lockId);
+      ack();
+      return Promise.resolve(true);
+    },
+    async withAcquire(handle, { lockId }) {
+      return taskProcessor.enqueue(
+        async ({ ack }) => {
+          locks.set(lockId, ack);
+          try {
+            return await handle();
+          } finally {
+            locks.delete(lockId);
+            ack();
+          }
+        },
+        { taskGroupId: lockId }
+      );
+    }
+  };
+};
+
 // src/utils/merge.ts
 var merge = (array, item, where, onExisting, onNotFound = () => void 0) => {
   let wasFound = false;
@@ -1317,6 +1509,7 @@ export {
   GlobalStreamCaughtUpType,
   IllegalStateError,
   InMemoryEventStoreDefaultStreamVersion,
+  InProcessLock,
   JSONParser,
   JsonDecoder,
   NO_CONCURRENCY_CHECK,
@@ -1328,6 +1521,7 @@ export {
   STREAM_EXISTS,
   StreamingCoordinator,
   StringDecoder,
+  TaskProcessor,
   ValidationError,
   ValidationErrors,
   WrapEventStore,
@@ -1367,6 +1561,7 @@ export {
   error,
   event,
   formatDateToUtcYYYYMMDD,
+  forwardToMessageBus,
   getInMemoryEventStore,
   getInMemoryMessageBus,
   globalStreamCaughtUp,
@@ -1398,6 +1593,7 @@ export {
   streamTrackingGlobalPosition,
   streamTransformations,
   sum,
+  tryPublishMessagesAfterCommit,
   verifyThat
 };
 //# sourceMappingURL=index.js.map