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

package/dist/index.cjs

@@ -8,6 +8,17 @@ var _http = require('http'); var _http2 = _interopRequireDefault(_http);
 
 // ../emmett/dist/chunk-BQYVGGNE.js
 var isNumber = (val) => typeof val === "number" && val === val;
+var isString = (val) => typeof val === "string";
+var EmmettError = class _EmmettError extends Error {
+  
+  constructor(options) {
+    const errorCode = options && typeof options === "object" && "errorCode" in options ? options.errorCode : isNumber(options) ? options : 500;
+    const message = options && typeof options === "object" && "message" in options ? options.message : isString(options) ? options : `Error with status code '${errorCode}' ocurred during Emmett processing`;
+    super(message);
+    this.errorCode = errorCode;
+    Object.setPrototypeOf(this, _EmmettError.prototype);
+  }
+};
 
 // ../emmett/dist/index.js
 var _uuid = require('uuid');
@@ -15,6 +26,7 @@ var _webstreamspolyfill = require('web-streams-polyfill');
 
 
 
+
 var _asyncretry = require('async-retry'); var _asyncretry2 = _interopRequireDefault(_asyncretry);
 
 
@@ -68,14 +80,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', _4 => _4.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', _5 => _5.reviver]));
+    if (_optionalChain([options, 'optionalAccess', _6 => _6.typeCheck]) && !_optionalChain([options, 'optionalAccess', _7 => _7.typeCheck, 'call', _8 => _8(parsed)]))
+      throw new ParseError(text);
+    return _optionalChain([options, 'optionalAccess', _9 => _9.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', _10 => _10.shouldRetryResult]) && opts.shouldRetryResult(result)) {
+          throw new EmmettError(
+            `Retrying because of result: ${JSONParser.stringify(result)}`
+          );
+        }
+        return result;
       } catch (error2) {
-        if (_optionalChain([opts, 'optionalAccess', _4 => _4.shouldRetryError]) && !opts.shouldRetryError(error2)) {
+        if (_optionalChain([opts, 'optionalAccess', _11 => _11.shouldRetryError]) && !opts.shouldRetryError(error2)) {
           bail(error2);
         }
         throw error2;
@@ -84,26 +123,84 @@ var asyncRetry = async (fn, opts) => {
     _nullishCoalesce(opts, () => ( { retries: 0 }))
   );
 };
-var ParseError = class extends Error {
-  constructor(text) {
-    super(`Cannot parse! ${text}`);
+var AssertionError = class extends Error {
+  constructor(message2) {
+    super(message2);
   }
 };
-var JSONParser = {
-  stringify: (value, options) => {
-    return JSON.stringify(
-      _optionalChain([options, 'optionalAccess', _5 => _5.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
+var isSubset = (superObj, subObj) => {
+  const sup = superObj;
+  const sub = subObj;
+  assertOk(sup);
+  assertOk(sub);
+  return Object.keys(sub).every((ele) => {
+    if (typeof sub[ele] == "object") {
+      return isSubset(sup[ele], sub[ele]);
+    }
+    return sub[ele] === sup[ele];
+  });
+};
+var assertFails = (message2) => {
+  throw new AssertionError(_nullishCoalesce(message2, () => ( "That should not ever happened, right?")));
+};
+var assertMatches = (actual, expected, message2) => {
+  if (!isSubset(actual, expected))
+    throw new AssertionError(
+      _nullishCoalesce(message2, () => ( `subObj:
+${JSONParser.stringify(expected)}
+is not subset of
+${JSONParser.stringify(actual)}`))
     );
-  },
-  parse: (text, options) => {
-    const parsed = JSON.parse(text, _optionalChain([options, 'optionalAccess', _6 => _6.reviver]));
-    if (_optionalChain([options, 'optionalAccess', _7 => _7.typeCheck]) && !_optionalChain([options, 'optionalAccess', _8 => _8.typeCheck, 'call', _9 => _9(parsed)]))
-      throw new ParseError(text);
-    return _optionalChain([options, 'optionalAccess', _10 => _10.map]) ? options.map(parsed) : parsed;
-  }
+};
+function assertOk(obj, message2) {
+  if (!obj) throw new AssertionError(_nullishCoalesce(message2, () => ( `Condition is not truthy`)));
+}
+function assertEqual(expected, actual, message2) {
+  if (expected !== actual)
+    throw new AssertionError(
+      `${_nullishCoalesce(message2, () => ( "Objects are not equal"))}:
+Expected: ${JSONParser.stringify(expected)}
+Actual: ${JSONParser.stringify(actual)}`
+    );
+}
+var WrapEventStore = (eventStore) => {
+  const appendedEvents = /* @__PURE__ */ new Map();
+  const wrapped = {
+    ...eventStore,
+    aggregateStream(streamName, options) {
+      return eventStore.aggregateStream(streamName, options);
+    },
+    async readStream(streamName, options) {
+      return await eventStore.readStream(
+        streamName,
+        options
+      );
+    },
+    appendToStream: async (streamName, events, options) => {
+      const result = await eventStore.appendToStream(
+        streamName,
+        events,
+        options
+      );
+      const currentStream = _nullishCoalesce(appendedEvents.get(streamName), () => ( [streamName, []]));
+      appendedEvents.set(streamName, [
+        streamName,
+        [...currentStream[1], ...events]
+      ]);
+      return result;
+    },
+    appendedEvents,
+    setup: async (streamName, events) => {
+      return eventStore.appendToStream(streamName, events);
+    }
+    // streamEvents: (): ReadableStream<
+    //   // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
+    //   ReadEvent<Event, ReadEventMetadataType> | GlobalSubscriptionEvent
+    // > => {
+    //   return eventStore.streamEvents();
+    // },
+  };
+  return wrapped;
 };
 var filter = (filter2) => new (0, _webstreamspolyfill.TransformStream)({
   transform(chunk, controller) {
@@ -246,85 +343,6 @@ var streamTransformations = {
   waitAtMost
 };
 var { retry: retry2 } = streamTransformations;
-var AssertionError = class extends Error {
-  constructor(message2) {
-    super(message2);
-  }
-};
-var isSubset = (superObj, subObj) => {
-  const sup = superObj;
-  const sub = subObj;
-  assertOk(sup);
-  assertOk(sub);
-  return Object.keys(sub).every((ele) => {
-    if (typeof sub[ele] == "object") {
-      return isSubset(sup[ele], sub[ele]);
-    }
-    return sub[ele] === sup[ele];
-  });
-};
-var assertFails = (message2) => {
-  throw new AssertionError(_nullishCoalesce(message2, () => ( "That should not ever happened, right?")));
-};
-var assertMatches = (actual, expected, message2) => {
-  if (!isSubset(actual, expected))
-    throw new AssertionError(
-      _nullishCoalesce(message2, () => ( `subObj:
-${JSONParser.stringify(expected)}
-is not subset of
-${JSONParser.stringify(actual)}`))
-    );
-};
-function assertOk(obj, message2) {
-  if (!obj) throw new AssertionError(_nullishCoalesce(message2, () => ( `Condition is not truthy`)));
-}
-function assertEqual(expected, actual, message2) {
-  if (expected !== actual)
-    throw new AssertionError(
-      `${_nullishCoalesce(message2, () => ( "Objects are not equal"))}:
-Expected: ${JSONParser.stringify(expected)}
-Actual: ${JSONParser.stringify(actual)}`
-    );
-}
-var WrapEventStore = (eventStore) => {
-  const appendedEvents = /* @__PURE__ */ new Map();
-  const wrapped = {
-    ...eventStore,
-    aggregateStream(streamName, options) {
-      return eventStore.aggregateStream(streamName, options);
-    },
-    async readStream(streamName, options) {
-      return await eventStore.readStream(
-        streamName,
-        options
-      );
-    },
-    appendToStream: async (streamName, events, options) => {
-      const result = await eventStore.appendToStream(
-        streamName,
-        events,
-        options
-      );
-      const currentStream = _nullishCoalesce(appendedEvents.get(streamName), () => ( [streamName, []]));
-      appendedEvents.set(streamName, [
-        streamName,
-        [...currentStream[1], ...events]
-      ]);
-      return result;
-    },
-    appendedEvents,
-    setup: async (streamName, events) => {
-      return eventStore.appendToStream(streamName, events);
-    }
-    // streamEvents: (): ReadableStream<
-    //   // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
-    //   ReadEvent<Event, ReadEventMetadataType> | GlobalSubscriptionEvent
-    // > => {
-    //   return eventStore.streamEvents();
-    // },
-  };
-  return wrapped;
-};
 
 // src/middlewares/problemDetailsMiddleware.ts
 var _httpproblemdetails = require('http-problem-details');