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

package/dist/index.js

@@ -24,13 +24,14 @@ var ConcurrencyError = class _ConcurrencyError extends EmmettError {
 };
 
 // ../emmett/dist/index.js
-import { v4 as uuid3 } from "uuid";
+import { v4 as uuid5 } from "uuid";
 import { TransformStream } from "web-streams-polyfill";
 import { v4 as uuid2 } from "uuid";
 import { v4 as uuid } from "uuid";
 import { TransformStream as TransformStream2 } from "web-streams-polyfill";
+import { v7 as uuid3 } from "uuid";
 import retry from "async-retry";
-import { v7 as uuid4 } from "uuid";
+import { v4 as uuid4 } from "uuid";
 import { ReadableStream } from "web-streams-polyfill";
 import "web-streams-polyfill";
 import { TransformStream as TransformStream3 } from "web-streams-polyfill";
@@ -102,12 +103,39 @@ var NotifyAboutNoActiveReadersStream = class extends TransformStream2 {
     }
   }
 };
+var ParseError = class extends Error {
+  constructor(text) {
+    super(`Cannot parse! ${text}`);
+  }
+};
+var JSONParser = {
+  stringify: (value, options) => {
+    return JSON.stringify(
+      options?.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, options?.reviver);
+    if (options?.typeCheck && !options?.typeCheck(parsed))
+      throw new ParseError(text);
+    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 {
-        return await fn();
+        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);
@@ -266,7 +294,7 @@ import {
 } from "@eventstore/db-client";
 
 // src/eventStore/consumers/eventStoreDBEventStoreProcessor.ts
-import { v7 as uuid5 } from "uuid";
+import { v7 as uuid6 } from "uuid";
 var EventStoreDBEventStoreProcessor = {
   result: {
     skip: (options) => ({
@@ -282,7 +310,7 @@ var EventStoreDBEventStoreProcessor = {
 var eventStoreDBEventStoreProcessor = (options) => {
   const { eachMessage } = options;
   let isActive = true;
-  options.processorId = options.processorId ?? uuid5();
+  options.processorId = options.processorId ?? uuid6();
   return {
     id: options.processorId,
     start: (_client) => {
@@ -495,40 +523,66 @@ var subscribe = (client, from, options) => from == void 0 || from.stream == $all
   fromRevision: toStreamPosition(options.startFrom),
   ...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 = resilience?.resubscribeOptions ?? {
+    ...EventStoreDBResubscribeDefaultOptions,
+    shouldRetryResult: () => isRunning,
+    shouldRetryError: (error) => isRunning && EventStoreDBResubscribeDefaultOptions.shouldRetryError(error)
+  };
+  const pipeMessages = (options) => {
     subscription = subscribe(client, from, options);
-    return new Promise((resolve, reject) => {
-      finished(
-        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) => {
+        finished(
+          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: from?.stream ?? $all,
+              options: {
+                ...from?.options ?? {},
+                ...!from || from?.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,7 +592,7 @@ var eventStoreDBSubscription = ({
       if (isRunning) return start;
       start = (async () => {
         isRunning = true;
-        return pullMessages(options);
+        return pipeMessages(options);
       })();
       return start;
     },
@@ -588,7 +642,8 @@ var eventStoreDBEventStoreConsumer = (options) => {
     client,
     from: options.from,
     eachBatch,
-    batchSize: pulling?.batchSize ?? DefaultEventStoreDBEventStoreProcessorBatchSize
+    batchSize: pulling?.batchSize ?? DefaultEventStoreDBEventStoreProcessorBatchSize,
+    resilience: options.resilience
   });
   const stop = async () => {
     if (!isRunning) return;
@@ -638,10 +693,12 @@ export {
   DefaultEventStoreDBEventStoreProcessorPullingFrequencyInMs,
   EventStoreDBEventStoreDefaultStreamVersion,
   EventStoreDBEventStoreProcessor,
+  EventStoreDBResubscribeDefaultOptions,
   eventStoreDBEventStoreConsumer,
   eventStoreDBEventStoreProcessor,
   eventStoreDBSubscription,
   getEventStoreDBEventStore,
+  isDatabaseUnavailableError,
   mapFromESDBEvent,
   zipEventStoreDBEventStoreMessageBatchPullerStartFrom
 };