@event-driven-io/emmett-esdb 0.38.6 → 0.39.0

package/dist/index.js

@@ -43,27 +43,10 @@ var ConcurrencyInMemoryDatabaseError = class _ConcurrencyInMemoryDatabaseError e
 };
 
 // ../emmett/dist/index.js
-import { v4 as uuid5 } from "uuid";
+import { v4 as uuid3 } from "uuid";
 import { v7 as uuid } from "uuid";
 import retry from "async-retry";
 import { v4 as uuid2 } from "uuid";
-import { TransformStream } from "web-streams-polyfill";
-import { v4 as uuid4 } from "uuid";
-import { v4 as uuid3 } from "uuid";
-import { TransformStream as TransformStream2 } from "web-streams-polyfill";
-import { ReadableStream } from "web-streams-polyfill";
-import "web-streams-polyfill";
-import { TransformStream as TransformStream3 } from "web-streams-polyfill";
-import { TransformStream as TransformStream4 } from "web-streams-polyfill";
-import { TransformStream as TransformStream5 } from "web-streams-polyfill";
-import {
-  TransformStream as TransformStream6
-} from "web-streams-polyfill";
-import { TransformStream as TransformStream7 } from "web-streams-polyfill";
-import { TransformStream as TransformStream8 } from "web-streams-polyfill";
-import { TransformStream as TransformStream9 } from "web-streams-polyfill";
-import { TransformStream as TransformStream10 } from "web-streams-polyfill";
-import { TransformStream as TransformStream11 } from "web-streams-polyfill";
 var STREAM_EXISTS = "STREAM_EXISTS";
 var STREAM_DOES_NOT_EXIST = "STREAM_DOES_NOT_EXIST";
 var NO_CONCURRENCY_CHECK = "NO_CONCURRENCY_CHECK";
@@ -576,44 +559,6 @@ var getInMemoryDatabase = () => {
     }
   };
 };
-var notifyAboutNoActiveReadersStream = (onNoActiveReaderCallback, options = {}) => new NotifyAboutNoActiveReadersStream(onNoActiveReaderCallback, options);
-var NotifyAboutNoActiveReadersStream = class extends TransformStream2 {
-  constructor(onNoActiveReaderCallback, options = {}) {
-    super({
-      cancel: (reason) => {
-        console.log("Stream was canceled. Reason:", reason);
-        this.stopChecking();
-      }
-    });
-    this.onNoActiveReaderCallback = onNoActiveReaderCallback;
-    this.streamId = options?.streamId ?? uuid3();
-    this.onNoActiveReaderCallback = onNoActiveReaderCallback;
-    this.startChecking(options?.intervalCheckInMs ?? 20);
-  }
-  checkInterval = null;
-  streamId;
-  _isStopped = false;
-  get hasActiveSubscribers() {
-    return !this._isStopped;
-  }
-  startChecking(interval) {
-    this.checkInterval = setInterval(() => {
-      this.checkNoActiveReader();
-    }, interval);
-  }
-  stopChecking() {
-    if (!this.checkInterval) return;
-    clearInterval(this.checkInterval);
-    this.checkInterval = null;
-    this._isStopped = true;
-    this.onNoActiveReaderCallback(this);
-  }
-  checkNoActiveReader() {
-    if (!this.readable.locked && !this._isStopped) {
-      this.stopChecking();
-    }
-  }
-};
 var getCheckpoint = (message2) => {
   return "checkpoint" in message2.metadata && // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
   isBigint(message2.metadata.checkpoint) ? (
@@ -827,153 +772,12 @@ var inMemoryReactor = (options) => {
     database
   };
 };
-var filter = (filter2) => new TransformStream3({
-  transform(chunk, controller) {
-    if (filter2(chunk)) {
-      controller.enqueue(chunk);
-    }
-  }
-});
-var map = (map2) => new TransformStream4({
-  transform(chunk, controller) {
-    controller.enqueue(map2(chunk));
-  }
-});
-var reduce = (reducer, initialValue) => new ReduceTransformStream(reducer, initialValue);
-var ReduceTransformStream = class extends TransformStream5 {
-  accumulator;
-  reducer;
-  constructor(reducer, initialValue) {
-    super({
-      transform: (chunk) => {
-        this.accumulator = this.reducer(this.accumulator, chunk);
-      },
-      flush: (controller) => {
-        controller.enqueue(this.accumulator);
-        controller.terminate();
-      }
-    });
-    this.accumulator = initialValue;
-    this.reducer = reducer;
-  }
-};
-var retryStream = (createSourceStream, handleChunk2, retryOptions = { forever: true, minTimeout: 25 }) => new TransformStream6({
-  start(controller) {
-    asyncRetry(
-      () => onRestream(createSourceStream, handleChunk2, controller),
-      retryOptions
-    ).catch((error2) => {
-      controller.error(error2);
-    });
-  }
-});
-var onRestream = async (createSourceStream, handleChunk2, controller) => {
-  const sourceStream = createSourceStream();
-  const reader = sourceStream.getReader();
-  try {
-    let done;
-    do {
-      const result = await reader.read();
-      done = result.done;
-      await handleChunk2(result, controller);
-      if (done) {
-        controller.terminate();
-      }
-    } while (!done);
-  } finally {
-    reader.releaseLock();
-  }
-};
-var skip = (limit) => new SkipTransformStream(limit);
-var SkipTransformStream = class extends TransformStream7 {
-  count = 0;
-  skip;
-  constructor(skip2) {
-    super({
-      transform: (chunk, controller) => {
-        this.count++;
-        if (this.count > this.skip) {
-          controller.enqueue(chunk);
-        }
-      }
-    });
-    this.skip = skip2;
-  }
-};
-var stopAfter = (stopCondition) => new TransformStream8({
-  transform(chunk, controller) {
-    controller.enqueue(chunk);
-    if (stopCondition(chunk)) {
-      controller.terminate();
-    }
-  }
-});
-var stopOn = (stopCondition) => new TransformStream9({
-  async transform(chunk, controller) {
-    if (!stopCondition(chunk)) {
-      controller.enqueue(chunk);
-      return;
-    }
-    await Promise.resolve();
-    controller.terminate();
-  }
-});
-var take = (limit) => new TakeTransformStream(limit);
-var TakeTransformStream = class extends TransformStream10 {
-  count = 0;
-  limit;
-  constructor(limit) {
-    super({
-      transform: (chunk, controller) => {
-        if (this.count < this.limit) {
-          this.count++;
-          controller.enqueue(chunk);
-        } else {
-          controller.terminate();
-        }
-      }
-    });
-    this.limit = limit;
-  }
-};
-var waitAtMost = (waitTimeInMs) => new TransformStream11({
-  start(controller) {
-    const timeoutId = setTimeout(() => {
-      controller.terminate();
-    }, waitTimeInMs);
-    const originalTerminate = controller.terminate.bind(controller);
-    controller.terminate = () => {
-      clearTimeout(timeoutId);
-      originalTerminate();
-    };
-  },
-  transform(chunk, controller) {
-    controller.enqueue(chunk);
-  }
-});
-var streamTransformations = {
-  filter,
-  take,
-  TakeTransformStream,
-  skip,
-  SkipTransformStream,
-  map,
-  notifyAboutNoActiveReadersStream,
-  NotifyAboutNoActiveReadersStream,
-  reduce,
-  ReduceTransformStream,
-  retry: retryStream,
-  stopAfter,
-  stopOn,
-  waitAtMost
-};
-var { retry: retry2 } = streamTransformations;
 
 // src/eventStore/consumers/eventStoreDBEventStoreConsumer.ts
 import {
   EventStoreDBClient as EventStoreDBClient3
 } from "@eventstore/db-client";
-import { v7 as uuid6 } from "uuid";
+import { v7 as uuid4 } from "uuid";
 
 // src/eventStore/consumers/subscriptions/index.ts
 import {
@@ -1223,11 +1027,11 @@ var eventStoreDBSubscription = ({
     }));
   };
   const pipeMessages = (options) => {
-    let retry3 = 0;
+    let retry2 = 0;
     return asyncRetry(
       () => new Promise((resolve, reject) => {
         console.info(
-          `Starting subscription. ${retry3++} retries. From: ${JSONParser.stringify(from ?? "$all")}, Start from: ${JSONParser.stringify(
+          `Starting subscription. ${retry2++} retries. From: ${JSONParser.stringify(from ?? "$all")}, Start from: ${JSONParser.stringify(
             options.startFrom
           )}`
         );
@@ -1324,8 +1128,8 @@ var eventStoreDBEventStoreConsumer = (options) => {
         reason: "No active processors"
       };
     const result = await Promise.allSettled(
-      activeProcessors.map((s) => {
-        return s.handle(messagesBatch, { client });
+      activeProcessors.map(async (s) => {
+        return await s.handle(messagesBatch, { client });
       })
     );
     const error = result.find((r) => r.status === "rejected")?.reason;
@@ -1353,7 +1157,7 @@ var eventStoreDBEventStoreConsumer = (options) => {
     await start;
   };
   return {
-    consumerId: options.consumerId ?? uuid6(),
+    consumerId: options.consumerId ?? uuid4(),
     get isRunning() {
       return isRunning;
     },