@event-driven-io/emmett-mongodb 0.38.7 → 0.39.0

package/dist/index.d.cts

@@ -21,11 +21,7 @@ type InlineProjectionHandlerOptions<EventType extends Event = Event, EventMetaDa
     updates: UpdateFilter<EventStream<Event>>;
     client: {};
 };
-declare const handleInlineProjections: <EventType extends Event = Event, EventMetaDataType extends MongoDBReadEventMetadata = Readonly<{
-    messageId: string;
-    streamPosition: bigint;
-    streamName: string;
-}>>(options: InlineProjectionHandlerOptions<EventType, EventMetaDataType>) => Promise<void>;
+declare const handleInlineProjections: <EventType extends Event = Event, EventMetaDataType extends MongoDBReadEventMetadata = MongoDBReadEventMetadata>(options: InlineProjectionHandlerOptions<EventType, EventMetaDataType>) => Promise<void>;
 type MongoDBWithNotNullDocumentEvolve<Doc extends Document, EventType extends Event, EventMetaDataType extends MongoDBReadEventMetadata = MongoDBReadEventMetadata> = ((document: Doc, event: ReadEvent<EventType, EventMetaDataType>) => Doc | null) | ((document: Doc, event: ReadEvent<EventType>) => Promise<Doc | null>);
 type MongoDBWithNullableDocumentEvolve<Doc extends Document, EventType extends Event, EventMetaDataType extends MongoDBReadEventMetadata = MongoDBReadEventMetadata> = ((document: Doc | null, event: ReadEvent<EventType, EventMetaDataType>) => Doc | null) | ((document: Doc | null, event: ReadEvent<EventType>) => Promise<Doc | null>);
 type MongoDBInlineProjectionOptions<Doc extends Document, EventType extends Event, EventMetaDataType extends MongoDBReadEventMetadata = MongoDBReadEventMetadata> = {
@@ -38,11 +34,7 @@ type MongoDBInlineProjectionOptions<Doc extends Document, EventType extends Even
     evolve: MongoDBWithNotNullDocumentEvolve<Doc, EventType, EventMetaDataType>;
     initialState: () => Doc;
 });
-declare const mongoDBInlineProjection: <Doc extends Document, EventType extends Event, EventMetaDataType extends MongoDBReadEventMetadata = Readonly<{
-    messageId: string;
-    streamPosition: bigint;
-    streamName: string;
-}>>(options: MongoDBInlineProjectionOptions<Doc, EventType, EventMetaDataType>) => MongoDBInlineProjectionDefinition;
+declare const mongoDBInlineProjection: <Doc extends Document, EventType extends Event, EventMetaDataType extends MongoDBReadEventMetadata = MongoDBReadEventMetadata>(options: MongoDBInlineProjectionOptions<Doc, EventType, EventMetaDataType>) => MongoDBInlineProjectionDefinition;
 
 type MongoDBInlineProjectionSpecGivenEvents<StreamNameType extends StreamName, EventType extends Event> = {
     streamName: StreamNameType;

package/dist/index.d.ts

@@ -21,11 +21,7 @@ type InlineProjectionHandlerOptions<EventType extends Event = Event, EventMetaDa
     updates: UpdateFilter<EventStream<Event>>;
     client: {};
 };
-declare const handleInlineProjections: <EventType extends Event = Event, EventMetaDataType extends MongoDBReadEventMetadata = Readonly<{
-    messageId: string;
-    streamPosition: bigint;
-    streamName: string;
-}>>(options: InlineProjectionHandlerOptions<EventType, EventMetaDataType>) => Promise<void>;
+declare const handleInlineProjections: <EventType extends Event = Event, EventMetaDataType extends MongoDBReadEventMetadata = MongoDBReadEventMetadata>(options: InlineProjectionHandlerOptions<EventType, EventMetaDataType>) => Promise<void>;
 type MongoDBWithNotNullDocumentEvolve<Doc extends Document, EventType extends Event, EventMetaDataType extends MongoDBReadEventMetadata = MongoDBReadEventMetadata> = ((document: Doc, event: ReadEvent<EventType, EventMetaDataType>) => Doc | null) | ((document: Doc, event: ReadEvent<EventType>) => Promise<Doc | null>);
 type MongoDBWithNullableDocumentEvolve<Doc extends Document, EventType extends Event, EventMetaDataType extends MongoDBReadEventMetadata = MongoDBReadEventMetadata> = ((document: Doc | null, event: ReadEvent<EventType, EventMetaDataType>) => Doc | null) | ((document: Doc | null, event: ReadEvent<EventType>) => Promise<Doc | null>);
 type MongoDBInlineProjectionOptions<Doc extends Document, EventType extends Event, EventMetaDataType extends MongoDBReadEventMetadata = MongoDBReadEventMetadata> = {
@@ -38,11 +34,7 @@ type MongoDBInlineProjectionOptions<Doc extends Document, EventType extends Even
     evolve: MongoDBWithNotNullDocumentEvolve<Doc, EventType, EventMetaDataType>;
     initialState: () => Doc;
 });
-declare const mongoDBInlineProjection: <Doc extends Document, EventType extends Event, EventMetaDataType extends MongoDBReadEventMetadata = Readonly<{
-    messageId: string;
-    streamPosition: bigint;
-    streamName: string;
-}>>(options: MongoDBInlineProjectionOptions<Doc, EventType, EventMetaDataType>) => MongoDBInlineProjectionDefinition;
+declare const mongoDBInlineProjection: <Doc extends Document, EventType extends Event, EventMetaDataType extends MongoDBReadEventMetadata = MongoDBReadEventMetadata>(options: MongoDBInlineProjectionOptions<Doc, EventType, EventMetaDataType>) => MongoDBInlineProjectionDefinition;
 
 type MongoDBInlineProjectionSpecGivenEvents<StreamNameType extends StreamName, EventType extends Event> = {
     streamName: StreamNameType;

package/dist/index.js

@@ -37,27 +37,10 @@ var ConcurrencyError = class _ConcurrencyError extends EmmettError {
 };
 
 // ../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";
 async function tryPublishMessagesAfterCommit(messages, options, context) {
   if (options?.onAfterCommit === void 0) return false;
   try {
@@ -94,16 +77,16 @@ var hasDuplicates = (array, predicate) => {
   return uniqueValues.size < mapped.length;
 };
 var getDuplicates = (array, predicate) => {
-  const map2 = /* @__PURE__ */ new Map();
+  const map = /* @__PURE__ */ new Map();
   for (let i = 0; i < array.length; i++) {
     const item = array[i];
     const key = predicate(item, i, array);
-    if (!map2.has(key)) {
-      map2.set(key, []);
+    if (!map.has(key)) {
+      map.set(key, []);
     }
-    map2.get(key).push(item);
+    map.get(key).push(item);
   }
-  return Array.from(map2.values()).filter((group) => group.length > 1).flat();
+  return Array.from(map.values()).filter((group) => group.length > 1).flat();
 };
 var merge = (array, item, where, onExisting, onNotFound = () => void 0) => {
   let wasFound = false;
@@ -348,29 +331,6 @@ var JSONParser = {
     return options?.map ? options.map(parsed) : parsed;
   }
 };
-var asyncRetry = async (fn, opts) => {
-  if (opts === void 0 || opts.retries === 0) return fn();
-  return retry(
-    async (bail) => {
-      try {
-        const result = await fn();
-        if (opts?.shouldRetryResult && opts.shouldRetryResult(result)) {
-          throw new EmmettError(
-            `Retrying because of result: ${JSONParser.stringify(result)}`
-          );
-        }
-        return result;
-      } catch (error2) {
-        if (opts?.shouldRetryError && !opts.shouldRetryError(error2)) {
-          bail(error2);
-          return void 0;
-        }
-        throw error2;
-      }
-    },
-    opts ?? { retries: 0 }
-  );
-};
 var AssertionError = class extends Error {
   constructor(message2) {
     super(message2);
@@ -398,44 +358,6 @@ function assertTrue(condition, message2) {
 function assertOk(obj, message2) {
   if (!obj) throw new AssertionError(message2 ?? `Condition is not truthy`);
 }
-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 filterProjections = (type, projections2) => {
   const inlineProjections2 = projections2.filter((projection2) => projection2.type === type).map(({ projection: projection2 }) => projection2);
   const duplicateRegistrations = arrayUtils.getDuplicates(
@@ -462,153 +384,12 @@ var projections = {
   inline: inlineProjections,
   async: asyncProjections
 };
-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/mongoDBEventStore.ts
 import {
   MongoClient as MongoClient2
 } from "mongodb";
-import { v4 as uuid6 } from "uuid";
+import { v4 as uuid4 } from "uuid";
 
 // src/eventStore/projections/mongoDBInlineProjection.ts
 var MongoDBDefaultInlineProjectionName = "_default";
@@ -897,7 +678,7 @@ var MongoDBEventStoreImplementation = class {
     const { streamType } = fromStreamName(streamName);
     const expectedStreamVersion = options?.expectedStreamVersion;
     const collection = await this.storage.collectionFor(streamType);
-    const filter2 = {
+    const filter = {
       streamName: { $eq: streamName }
     };
     const eventsSliceArr = [];
@@ -910,7 +691,7 @@ var MongoDBEventStoreImplementation = class {
       eventsSliceArr.push(Number(options.to));
     }
     const eventsSlice = eventsSliceArr.length > 1 ? { $slice: eventsSliceArr } : 1;
-    const stream = await collection.findOne(filter2, {
+    const stream = await collection.findOne(filter, {
       useBigInt64: true,
       projection: {
         metadata: 1,
@@ -967,7 +748,7 @@ var MongoDBEventStoreImplementation = class {
     let streamOffset = currentStreamVersion;
     const eventsToAppend = events.map((event) => {
       const metadata = {
-        messageId: uuid6(),
+        messageId: uuid4(),
         streamName,
         streamPosition: ++streamOffset
       };