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

package/dist/index.cjs

@@ -1,4 +1,4 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4;// ../emmett/dist/chunk-O2VMBOV4.js
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;// ../emmett/dist/chunk-O2VMBOV4.js
 var isNumber = (val) => typeof val === "number" && val === val;
 var isString = (val) => typeof val === "string";
 var isErrorConstructor = (expect) => {
@@ -41,23 +41,6 @@ var _uuid = require('uuid');
 
 var _asyncretry = require('async-retry'); var _asyncretry2 = _interopRequireDefault(_asyncretry);
 
-var _webstreamspolyfill = require('web-streams-polyfill');
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
 async function tryPublishMessagesAfterCommit(messages, options, context) {
   if (_optionalChain([options, 'optionalAccess', _4 => _4.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 _optionalChain([options, 'optionalAccess', _16 => _16.map]) ? options.map(parsed) : parsed;
   }
 };
-var asyncRetry = async (fn, opts) => {
-  if (opts === void 0 || opts.retries === 0) return fn();
-  return _asyncretry2.default.call(void 0, 
-    async (bail) => {
-      try {
-        const result = await fn();
-        if (_optionalChain([opts, 'optionalAccess', _17 => _17.shouldRetryResult]) && opts.shouldRetryResult(result)) {
-          throw new EmmettError(
-            `Retrying because of result: ${JSONParser.stringify(result)}`
-          );
-        }
-        return result;
-      } catch (error2) {
-        if (_optionalChain([opts, 'optionalAccess', _18 => _18.shouldRetryError]) && !opts.shouldRetryError(error2)) {
-          bail(error2);
-          return void 0;
-        }
-        throw error2;
-      }
-    },
-    _nullishCoalesce(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(_nullishCoalesce(message2, () => ( `Condition is not truthy`)));
 }
-var notifyAboutNoActiveReadersStream = (onNoActiveReaderCallback, options = {}) => new NotifyAboutNoActiveReadersStream(onNoActiveReaderCallback, options);
-var NotifyAboutNoActiveReadersStream = (_class = class extends _webstreamspolyfill.TransformStream {
-  constructor(onNoActiveReaderCallback, options = {}) {
-    super({
-      cancel: (reason) => {
-        console.log("Stream was canceled. Reason:", reason);
-        this.stopChecking();
-      }
-    });_class.prototype.__init.call(this);_class.prototype.__init2.call(this);;
-    this.onNoActiveReaderCallback = onNoActiveReaderCallback;
-    this.streamId = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _19 => _19.streamId]), () => ( _uuid.v4.call(void 0, )));
-    this.onNoActiveReaderCallback = onNoActiveReaderCallback;
-    this.startChecking(_nullishCoalesce(_optionalChain([options, 'optionalAccess', _20 => _20.intervalCheckInMs]), () => ( 20)));
-  }
-  __init() {this.checkInterval = null}
-  
-  __init2() {this._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();
-    }
-  }
-}, _class);
 var filterProjections = (type, projections2) => {
   const inlineProjections2 = projections2.filter((projection2) => projection2.type === type).map(({ projection: projection2 }) => projection2);
   const duplicateRegistrations = arrayUtils.getDuplicates(
@@ -462,147 +384,6 @@ var projections = {
   inline: inlineProjections,
   async: asyncProjections
 };
-var filter = (filter2) => new (0, _webstreamspolyfill.TransformStream)({
-  transform(chunk, controller) {
-    if (filter2(chunk)) {
-      controller.enqueue(chunk);
-    }
-  }
-});
-var map = (map2) => new (0, _webstreamspolyfill.TransformStream)({
-  transform(chunk, controller) {
-    controller.enqueue(map2(chunk));
-  }
-});
-var reduce = (reducer, initialValue) => new ReduceTransformStream(reducer, initialValue);
-var ReduceTransformStream = class extends _webstreamspolyfill.TransformStream {
-  
-  
-  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 (0, _webstreamspolyfill.TransformStream)({
-  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 = (_class2 = class extends _webstreamspolyfill.TransformStream {
-  __init3() {this.count = 0}
-  
-  constructor(skip2) {
-    super({
-      transform: (chunk, controller) => {
-        this.count++;
-        if (this.count > this.skip) {
-          controller.enqueue(chunk);
-        }
-      }
-    });_class2.prototype.__init3.call(this);;
-    this.skip = skip2;
-  }
-}, _class2);
-var stopAfter = (stopCondition) => new (0, _webstreamspolyfill.TransformStream)({
-  transform(chunk, controller) {
-    controller.enqueue(chunk);
-    if (stopCondition(chunk)) {
-      controller.terminate();
-    }
-  }
-});
-var stopOn = (stopCondition) => new (0, _webstreamspolyfill.TransformStream)({
-  async transform(chunk, controller) {
-    if (!stopCondition(chunk)) {
-      controller.enqueue(chunk);
-      return;
-    }
-    await Promise.resolve();
-    controller.terminate();
-  }
-});
-var take = (limit) => new TakeTransformStream(limit);
-var TakeTransformStream = (_class3 = class extends _webstreamspolyfill.TransformStream {
-  __init4() {this.count = 0}
-  
-  constructor(limit) {
-    super({
-      transform: (chunk, controller) => {
-        if (this.count < this.limit) {
-          this.count++;
-          controller.enqueue(chunk);
-        } else {
-          controller.terminate();
-        }
-      }
-    });_class3.prototype.__init4.call(this);;
-    this.limit = limit;
-  }
-}, _class3);
-var waitAtMost = (waitTimeInMs) => new (0, _webstreamspolyfill.TransformStream)({
-  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
 
@@ -714,18 +495,18 @@ var MongoDBInlineProjectionSpec = {
                   if (!isErrorConstructor(args[0])) {
                     assertTrue(
                       args[0](error),
-                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _21 => _21.toString, 'call', _22 => _22()])}`
+                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _17 => _17.toString, 'call', _18 => _18()])}`
                     );
                     return;
                   }
                   assertTrue(
                     error instanceof args[0],
-                    `Caught error is not an instance of the expected type: ${_optionalChain([error, 'optionalAccess', _23 => _23.toString, 'call', _24 => _24()])}`
+                    `Caught error is not an instance of the expected type: ${_optionalChain([error, 'optionalAccess', _19 => _19.toString, 'call', _20 => _20()])}`
                   );
                   if (args[1]) {
                     assertTrue(
                       args[1](error),
-                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _25 => _25.toString, 'call', _26 => _26()])}`
+                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _21 => _21.toString, 'call', _22 => _22()])}`
                     );
                   }
                 } finally {
@@ -865,15 +646,15 @@ var mongoDBEventStoreStorage = (options) => {
 
 // src/eventStore/mongoDBEventStore.ts
 var MongoDBEventStoreDefaultStreamVersion = 0n;
-var MongoDBEventStoreImplementation = (_class4 = class {
+var MongoDBEventStoreImplementation = (_class = class {
   
   
   
-  __init5() {this.isClosed = false}
+  __init() {this.isClosed = false}
   
   
   
-  constructor(options) {;_class4.prototype.__init5.call(this);_class4.prototype.__init6.call(this);_class4.prototype.__init7.call(this);_class4.prototype.__init8.call(this);
+  constructor(options) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);
     this.options = options;
     this.client = "client" in options && options.client ? options.client : new (0, _mongodb.MongoClient)(options.connectionString, options.clientOptions);
     this.shouldManageClientLifetime = !("client" in options);
@@ -895,9 +676,9 @@ var MongoDBEventStoreImplementation = (_class4 = class {
   }
   async readStream(streamName, options) {
     const { streamType } = fromStreamName(streamName);
-    const expectedStreamVersion = _optionalChain([options, 'optionalAccess', _27 => _27.expectedStreamVersion]);
+    const expectedStreamVersion = _optionalChain([options, 'optionalAccess', _23 => _23.expectedStreamVersion]);
     const collection = await this.storage.collectionFor(streamType);
-    const filter2 = {
+    const filter = {
       streamName: { $eq: streamName }
     };
     const eventsSliceArr = [];
@@ -910,7 +691,7 @@ var MongoDBEventStoreImplementation = (_class4 = 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,
@@ -936,7 +717,7 @@ var MongoDBEventStoreImplementation = (_class4 = class {
     };
   }
   async aggregateStream(streamName, options) {
-    const stream = await this.readStream(streamName, _optionalChain([options, 'optionalAccess', _28 => _28.read]));
+    const stream = await this.readStream(streamName, _optionalChain([options, 'optionalAccess', _24 => _24.read]));
     const state = stream.events.reduce(options.evolve, options.initialState());
     return {
       state,
@@ -946,7 +727,7 @@ var MongoDBEventStoreImplementation = (_class4 = class {
   }
   async appendToStream(streamName, events, options) {
     const { streamId, streamType } = fromStreamName(streamName);
-    const expectedStreamVersion = _optionalChain([options, 'optionalAccess', _29 => _29.expectedStreamVersion]);
+    const expectedStreamVersion = _optionalChain([options, 'optionalAccess', _25 => _25.expectedStreamVersion]);
     const collection = await this.storage.collectionFor(streamType);
     const stream = await collection.findOne(
       { streamName: { $eq: streamName } },
@@ -958,7 +739,7 @@ var MongoDBEventStoreImplementation = (_class4 = class {
         }
       }
     );
-    const currentStreamVersion = _nullishCoalesce(_optionalChain([stream, 'optionalAccess', _30 => _30.metadata, 'access', _31 => _31.streamPosition]), () => ( MongoDBEventStoreDefaultStreamVersion));
+    const currentStreamVersion = _nullishCoalesce(_optionalChain([stream, 'optionalAccess', _26 => _26.metadata, 'access', _27 => _27.streamPosition]), () => ( MongoDBEventStoreDefaultStreamVersion));
     assertExpectedVersionMatchesCurrent(
       currentStreamVersion,
       expectedStreamVersion,
@@ -996,7 +777,7 @@ var MongoDBEventStoreImplementation = (_class4 = class {
     };
     if (this.inlineProjections) {
       await handleInlineProjections({
-        readModels: _nullishCoalesce(_optionalChain([stream, 'optionalAccess', _32 => _32.projections]), () => ( {})),
+        readModels: _nullishCoalesce(_optionalChain([stream, 'optionalAccess', _28 => _28.projections]), () => ( {})),
         streamId,
         events: eventsToAppend,
         projections: this.inlineProjections,
@@ -1016,7 +797,7 @@ var MongoDBEventStoreImplementation = (_class4 = class {
     if (!updatedStream) {
       throw new ExpectedVersionConflictError(
         currentStreamVersion,
-        _nullishCoalesce(_optionalChain([options, 'optionalAccess', _33 => _33.expectedStreamVersion]), () => ( 0n))
+        _nullishCoalesce(_optionalChain([options, 'optionalAccess', _29 => _29.expectedStreamVersion]), () => ( 0n))
       );
     }
     await tryPublishMessagesAfterCommit(
@@ -1031,7 +812,7 @@ var MongoDBEventStoreImplementation = (_class4 = class {
       createdNewStream: currentStreamVersion === MongoDBEventStoreDefaultStreamVersion
     };
   }
-  __init6() {this.collectionFor = async (streamType) => {
+  __init2() {this.collectionFor = async (streamType) => {
     return this.storage.collectionFor(streamType);
   }}
   /**
@@ -1041,7 +822,7 @@ var MongoDBEventStoreImplementation = (_class4 = class {
    *
    * @memberof Closeable
    */
-  __init7() {this.close = () => {
+  __init3() {this.close = () => {
     if (this.isClosed) return Promise.resolve();
     this.isClosed = true;
     if (!this.shouldManageClientLifetime) return Promise.resolve();
@@ -1067,7 +848,7 @@ var MongoDBEventStoreImplementation = (_class4 = class {
         projection: { [`projections.${projectionName}`]: 1 }
       }
     );
-    return _nullishCoalesce(_optionalChain([result, 'optionalAccess', _34 => _34.projections, 'optionalAccess', _35 => _35[projectionName]]), () => ( null));
+    return _nullishCoalesce(_optionalChain([result, 'optionalAccess', _30 => _30.projections, 'optionalAccess', _31 => _31[projectionName]]), () => ( null));
   }
   async findInlineProjection(streamFilter, projectionQuery, queryOptions) {
     const parsedStreamFilter = parseMultiProjectionQueryStreamFilter(streamFilter);
@@ -1092,13 +873,13 @@ var MongoDBEventStoreImplementation = (_class4 = class {
         projection: { [`projections.${projectionName}`]: 1 }
       }
     );
-    if (_optionalChain([queryOptions, 'optionalAccess', _36 => _36.skip])) {
+    if (_optionalChain([queryOptions, 'optionalAccess', _32 => _32.skip])) {
       query = query.skip(queryOptions.skip);
     }
-    if (_optionalChain([queryOptions, 'optionalAccess', _37 => _37.limit])) {
+    if (_optionalChain([queryOptions, 'optionalAccess', _33 => _33.limit])) {
       query = query.limit(queryOptions.limit);
     }
-    if (_optionalChain([queryOptions, 'optionalAccess', _38 => _38.sort])) {
+    if (_optionalChain([queryOptions, 'optionalAccess', _34 => _34.sort])) {
       const sort = prependMongoFilterWithProjectionPrefix(
         queryOptions.sort,
         prefix
@@ -1127,11 +908,11 @@ var MongoDBEventStoreImplementation = (_class4 = class {
     const total = await collection.countDocuments({ $and: filters });
     return total;
   }
-  __init8() {this.getConnectedClient = async () => {
+  __init4() {this.getConnectedClient = async () => {
     if (!this.isClosed) await this.client.connect();
     return this.client;
   }}
-}, _class4);
+}, _class);
 function parseSingleProjectionQueryStreamFilter(streamFilter) {
   const projectionName = _nullishCoalesce(streamFilter.projectionName, () => ( MongoDBDefaultInlineProjectionName));
   if ("streamName" in streamFilter) {