@event-driven-io/emmett-esdb 0.36.0 → 0.38.0-alpha.1

package/dist/index.cjs

@@ -15,7 +15,7 @@ var ConcurrencyError = class _ConcurrencyError extends EmmettError {
   constructor(current, expected, message) {
     super({
       errorCode: 412,
-      message: _nullishCoalesce(message, () => ( `Expected version ${expected.toString()} does not match current ${_optionalChain([current, 'optionalAccess', _ => _.toString, 'call', _2 => _2()])}`))
+      message: _nullishCoalesce(message, () => ( `Expected version ${expected.toString()} does not match current ${_optionalChain([current, 'optionalAccess', _2 => _2.toString, 'call', _3 => _3()])}`))
     });
     this.current = current;
     this.expected = expected;
@@ -29,6 +29,7 @@ var _webstreamspolyfill = require('web-streams-polyfill');
 
 
 
+
 var _asyncretry = require('async-retry'); var _asyncretry2 = _interopRequireDefault(_asyncretry);
 
 
@@ -60,7 +61,7 @@ var assertExpectedVersionMatchesCurrent = (current, expected, defaultVersion) =>
 };
 var ExpectedVersionConflictError = class _ExpectedVersionConflictError extends ConcurrencyError {
   constructor(current, expected) {
-    super(_optionalChain([current, 'optionalAccess', _3 => _3.toString, 'call', _4 => _4()]), _optionalChain([expected, 'optionalAccess', _5 => _5.toString, 'call', _6 => _6()]));
+    super(_optionalChain([current, 'optionalAccess', _4 => _4.toString, 'call', _5 => _5()]), _optionalChain([expected, 'optionalAccess', _6 => _6.toString, 'call', _7 => _7()]));
     Object.setPrototypeOf(this, _ExpectedVersionConflictError.prototype);
   }
 };
@@ -74,9 +75,9 @@ var NotifyAboutNoActiveReadersStream = (_class = class extends _webstreamspolyfi
       }
     });_class.prototype.__init.call(this);_class.prototype.__init2.call(this);;
     this.onNoActiveReaderCallback = onNoActiveReaderCallback;
-    this.streamId = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _7 => _7.streamId]), () => ( _uuid.v4.call(void 0, )));
+    this.streamId = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _8 => _8.streamId]), () => ( _uuid.v4.call(void 0, )));
     this.onNoActiveReaderCallback = onNoActiveReaderCallback;
-    this.startChecking(_nullishCoalesce(_optionalChain([options, 'optionalAccess', _8 => _8.intervalCheckInMs]), () => ( 20)));
+    this.startChecking(_nullishCoalesce(_optionalChain([options, 'optionalAccess', _9 => _9.intervalCheckInMs]), () => ( 20)));
   }
   __init() {this.checkInterval = null}
   
@@ -102,14 +103,41 @@ var NotifyAboutNoActiveReadersStream = (_class = class extends _webstreamspolyfi
     }
   }
 }, _class);
+var ParseError = class extends Error {
+  constructor(text) {
+    super(`Cannot parse! ${text}`);
+  }
+};
+var JSONParser = {
+  stringify: (value, options) => {
+    return JSON.stringify(
+      _optionalChain([options, 'optionalAccess', _10 => _10.map]) ? options.map(value) : value,
+      //TODO: Consider adding support to DateTime and adding specific format to mark that's a bigint
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+      (_, v) => typeof v === "bigint" ? v.toString() : v
+    );
+  },
+  parse: (text, options) => {
+    const parsed = JSON.parse(text, _optionalChain([options, 'optionalAccess', _11 => _11.reviver]));
+    if (_optionalChain([options, 'optionalAccess', _12 => _12.typeCheck]) && !_optionalChain([options, 'optionalAccess', _13 => _13.typeCheck, 'call', _14 => _14(parsed)]))
+      throw new ParseError(text);
+    return _optionalChain([options, 'optionalAccess', _15 => _15.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 {
-        return await fn();
+        const result = await fn();
+        if (_optionalChain([opts, 'optionalAccess', _16 => _16.shouldRetryResult]) && opts.shouldRetryResult(result)) {
+          throw new EmmettError(
+            `Retrying because of result: ${JSONParser.stringify(result)}`
+          );
+        }
+        return result;
       } catch (error2) {
-        if (_optionalChain([opts, 'optionalAccess', _9 => _9.shouldRetryError]) && !opts.shouldRetryError(error2)) {
+        if (_optionalChain([opts, 'optionalAccess', _17 => _17.shouldRetryError]) && !opts.shouldRetryError(error2)) {
           bail(error2);
         }
         throw error2;
@@ -348,7 +376,7 @@ var getEventStoreDBEventStore = (eventStore) => {
   return {
     async aggregateStream(streamName, options) {
       const { evolve, initialState, read } = options;
-      const expectedStreamVersion = _optionalChain([read, 'optionalAccess', _10 => _10.expectedStreamVersion]);
+      const expectedStreamVersion = _optionalChain([read, 'optionalAccess', _18 => _18.expectedStreamVersion]);
       let state = initialState();
       let currentStreamVersion = EventStoreDBEventStoreDefaultStreamVersion;
       let lastEventGlobalPosition = void 0;
@@ -360,7 +388,7 @@ var getEventStoreDBEventStore = (eventStore) => {
           if (!event) continue;
           state = evolve(state, mapFromESDBEvent(event));
           currentStreamVersion = event.revision;
-          lastEventGlobalPosition = _optionalChain([event, 'access', _11 => _11.position, 'optionalAccess', _12 => _12.commit]);
+          lastEventGlobalPosition = _optionalChain([event, 'access', _19 => _19.position, 'optionalAccess', _20 => _20.commit]);
         }
         assertExpectedVersionMatchesCurrent(
           currentStreamVersion,
@@ -420,7 +448,7 @@ var getEventStoreDBEventStore = (eventStore) => {
       try {
         const serializedEvents = events.map(_dbclient.jsonEvent);
         const expectedRevision = toExpectedRevision(
-          _optionalChain([options, 'optionalAccess', _13 => _13.expectedStreamVersion])
+          _optionalChain([options, 'optionalAccess', _21 => _21.expectedStreamVersion])
         );
         const appendResult = await eventStore.appendToStream(
           streamName,
@@ -490,45 +518,71 @@ var toStreamPosition = (startFrom) => startFrom === "BEGINNING" ? _dbclient.STAR
 var subscribe = (client, from, options) => from == void 0 || from.stream == $all ? client.subscribeToAll({
   fromPosition: toGlobalPosition(options.startFrom),
   filter: _dbclient.excludeSystemEvents.call(void 0, ),
-  ..._nullishCoalesce(_optionalChain([from, 'optionalAccess', _14 => _14.options]), () => ( {}))
+  ..._nullishCoalesce(_optionalChain([from, 'optionalAccess', _22 => _22.options]), () => ( {}))
 }) : client.subscribeToStream(from.stream, {
   fromRevision: toStreamPosition(options.startFrom),
   ..._nullishCoalesce(from.options, () => ( {}))
 });
+var isDatabaseUnavailableError = (error) => error instanceof Error && "type" in error && error.type === "unavailable" && "code" in error && error.code === 14;
+var EventStoreDBResubscribeDefaultOptions = {
+  forever: true,
+  minTimeout: 100,
+  factor: 1.5,
+  shouldRetryError: (error) => !isDatabaseUnavailableError(error)
+};
 var eventStoreDBSubscription = ({
   client,
   from,
   //batchSize,
-  eachBatch
+  eachBatch,
+  resilience
 }) => {
   let isRunning = false;
   let start;
   let subscription;
-  const pullMessages = async (options) => {
+  const resubscribeOptions = _nullishCoalesce(_optionalChain([resilience, 'optionalAccess', _23 => _23.resubscribeOptions]), () => ( {
+    ...EventStoreDBResubscribeDefaultOptions,
+    shouldRetryResult: () => isRunning,
+    shouldRetryError: (error) => isRunning && EventStoreDBResubscribeDefaultOptions.shouldRetryError(error)
+  }));
+  const pipeMessages = (options) => {
     subscription = subscribe(client, from, options);
-    return new Promise((resolve, reject) => {
-      _stream.finished.call(void 0, 
-        subscription.on("data", async (resolvedEvent) => {
-          if (!resolvedEvent.event) return;
-          const event = mapFromESDBEvent(
-            resolvedEvent.event
-          );
-          const result = await eachBatch({ messages: [event] });
-          if (result && result.type === "STOP") {
-            await subscription.unsubscribe();
-          }
-        }),
-        (error) => {
-          if (!error) {
+    return asyncRetry(
+      () => new Promise((resolve, reject) => {
+        _stream.finished.call(void 0, 
+          subscription.on("data", async (resolvedEvent) => {
+            if (!resolvedEvent.event) return;
+            const event = mapFromESDBEvent(
+              resolvedEvent.event
+            );
+            const result = await eachBatch({ messages: [event] });
+            if (result && result.type === "STOP") {
+              isRunning = false;
+              await subscription.unsubscribe();
+            }
+            from = {
+              stream: _nullishCoalesce(_optionalChain([from, 'optionalAccess', _24 => _24.stream]), () => ( $all)),
+              options: {
+                ..._nullishCoalesce(_optionalChain([from, 'optionalAccess', _25 => _25.options]), () => ( {})),
+                ...!from || _optionalChain([from, 'optionalAccess', _26 => _26.stream]) === $all ? {
+                  fromPosition: resolvedEvent.event.position
+                } : { fromRevision: resolvedEvent.event.revision }
+              }
+            };
+          }),
+          (error) => {
+            if (error) {
+              console.error(`Received error: ${JSON.stringify(error)}.`);
+              reject(error);
+              return;
+            }
             console.info(`Stopping subscription.`);
             resolve();
-            return;
           }
-          console.error(`Received error: ${JSON.stringify(error)}.`);
-          reject(error);
-        }
-      );
-    });
+        );
+      }),
+      resubscribeOptions
+    );
   };
   return {
     get isRunning() {
@@ -538,14 +592,14 @@ var eventStoreDBSubscription = ({
       if (isRunning) return start;
       start = (async () => {
         isRunning = true;
-        return pullMessages(options);
+        return pipeMessages(options);
       })();
       return start;
     },
     stop: async () => {
       if (!isRunning) return;
       isRunning = false;
-      await _optionalChain([subscription, 'optionalAccess', _15 => _15.unsubscribe, 'call', _16 => _16()]);
+      await _optionalChain([subscription, 'optionalAccess', _27 => _27.unsubscribe, 'call', _28 => _28()]);
       await start;
     }
   };
@@ -579,7 +633,7 @@ var eventStoreDBEventStoreConsumer = (options) => {
       })
     );
     return result.some(
-      (r) => r.status === "fulfilled" && _optionalChain([r, 'access', _17 => _17.value, 'optionalAccess', _18 => _18.type]) !== "STOP"
+      (r) => r.status === "fulfilled" && _optionalChain([r, 'access', _29 => _29.value, 'optionalAccess', _30 => _30.type]) !== "STOP"
     ) ? void 0 : {
       type: "STOP"
     };
@@ -588,7 +642,8 @@ var eventStoreDBEventStoreConsumer = (options) => {
     client,
     from: options.from,
     eachBatch,
-    batchSize: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _19 => _19.batchSize]), () => ( DefaultEventStoreDBEventStoreProcessorBatchSize))
+    batchSize: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _31 => _31.batchSize]), () => ( DefaultEventStoreDBEventStoreProcessorBatchSize)),
+    resilience: options.resilience
   });
   const stop = async () => {
     if (!isRunning) return;
@@ -644,5 +699,7 @@ var eventStoreDBEventStoreConsumer = (options) => {
 
 
 
-exports.$all = $all; exports.DefaultEventStoreDBEventStoreProcessorBatchSize = DefaultEventStoreDBEventStoreProcessorBatchSize; exports.DefaultEventStoreDBEventStoreProcessorPullingFrequencyInMs = DefaultEventStoreDBEventStoreProcessorPullingFrequencyInMs; exports.EventStoreDBEventStoreDefaultStreamVersion = EventStoreDBEventStoreDefaultStreamVersion; exports.EventStoreDBEventStoreProcessor = EventStoreDBEventStoreProcessor; exports.eventStoreDBEventStoreConsumer = eventStoreDBEventStoreConsumer; exports.eventStoreDBEventStoreProcessor = eventStoreDBEventStoreProcessor; exports.eventStoreDBSubscription = eventStoreDBSubscription; exports.getEventStoreDBEventStore = getEventStoreDBEventStore; exports.mapFromESDBEvent = mapFromESDBEvent; exports.zipEventStoreDBEventStoreMessageBatchPullerStartFrom = zipEventStoreDBEventStoreMessageBatchPullerStartFrom;
+
+
+exports.$all = $all; exports.DefaultEventStoreDBEventStoreProcessorBatchSize = DefaultEventStoreDBEventStoreProcessorBatchSize; exports.DefaultEventStoreDBEventStoreProcessorPullingFrequencyInMs = DefaultEventStoreDBEventStoreProcessorPullingFrequencyInMs; exports.EventStoreDBEventStoreDefaultStreamVersion = EventStoreDBEventStoreDefaultStreamVersion; exports.EventStoreDBEventStoreProcessor = EventStoreDBEventStoreProcessor; exports.EventStoreDBResubscribeDefaultOptions = EventStoreDBResubscribeDefaultOptions; exports.eventStoreDBEventStoreConsumer = eventStoreDBEventStoreConsumer; exports.eventStoreDBEventStoreProcessor = eventStoreDBEventStoreProcessor; exports.eventStoreDBSubscription = eventStoreDBSubscription; exports.getEventStoreDBEventStore = getEventStoreDBEventStore; exports.isDatabaseUnavailableError = isDatabaseUnavailableError; exports.mapFromESDBEvent = mapFromESDBEvent; exports.zipEventStoreDBEventStoreMessageBatchPullerStartFrom = zipEventStoreDBEventStoreMessageBatchPullerStartFrom;
 //# sourceMappingURL=index.cjs.map