@event-driven-io/emmett-expressjs 0.20.2-alpha.4 → 0.20.2-alpha.5

package/dist/index.cjs

@@ -6,9 +6,8 @@ var _express = require('express'); var _express2 = _interopRequireDefault(_expre
 
 var _http = require('http'); var _http2 = _interopRequireDefault(_http);
 
-// ../emmett/dist/chunk-3XBWME34.js
-var a = ((n) => (n.NOT_A_NONEMPTY_STRING = "NOT_A_NONEMPTY_STRING", n.NOT_A_POSITIVE_NUMBER = "NOT_A_POSITIVE_NUMBER", n.NOT_AN_UNSIGNED_BIGINT = "NOT_AN_UNSIGNED_BIGINT", n))(a || {});
-var s = (t) => typeof t == "number" && t === t;
+// ../emmett/dist/chunk-AEEEXE2R.js
+var isNumber = (val) => typeof val === "number" && val === val;
 
 // ../emmett/dist/index.js
 var _uuid = require('uuid');
@@ -28,14 +27,21 @@ var _asyncretry = require('async-retry'); var _asyncretry2 = _interopRequireDefa
 
 
 
-var O = (t, e = {}) => new S(t, e);
-var S = (_class = class extends _webstreamspolyfill.TransformStream {
-  constructor(r2, n = {}) {
-    super({ cancel: (o2) => {
-      console.log("Stream was canceled. Reason:", o2), this.stopChecking();
-    } });_class.prototype.__init.call(this);_class.prototype.__init2.call(this);;
-    this.onNoActiveReaderCallback = r2;
-    this.streamId = _nullishCoalesce(_optionalChain([n, 'optionalAccess', _ => _.streamId]), () => ( _uuid.v4.call(void 0, ))), this.onNoActiveReaderCallback = r2, this.startChecking(_nullishCoalesce(_optionalChain([n, 'optionalAccess', _2 => _2.intervalCheckInMs]), () => ( 20)));
+
+
+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', _2 => _2.streamId]), () => ( _uuid.v4.call(void 0, )));
+    this.onNoActiveReaderCallback = onNoActiveReaderCallback;
+    this.startChecking(_nullishCoalesce(_optionalChain([options, 'optionalAccess', _3 => _3.intervalCheckInMs]), () => ( 20)));
   }
   __init() {this.checkInterval = null}
   
@@ -43,148 +49,275 @@ var S = (_class = class extends _webstreamspolyfill.TransformStream {
   get hasActiveSubscribers() {
     return !this._isStopped;
   }
-  startChecking(r2) {
+  startChecking(interval) {
     this.checkInterval = setInterval(() => {
       this.checkNoActiveReader();
-    }, r2);
+    }, interval);
   }
   stopChecking() {
-    this.checkInterval && (clearInterval(this.checkInterval), this.checkInterval = null, this._isStopped = true, this.onNoActiveReaderCallback(this));
+    if (!this.checkInterval) return;
+    clearInterval(this.checkInterval);
+    this.checkInterval = null;
+    this._isStopped = true;
+    this.onNoActiveReaderCallback(this);
   }
   checkNoActiveReader() {
-    !this.readable.locked && !this._isStopped && this.stopChecking();
+    if (!this.readable.locked && !this._isStopped) {
+      this.stopChecking();
+    }
   }
 }, _class);
-var w2 = async (t, e) => e === void 0 || e.retries === 0 ? t() : _asyncretry2.default.call(void 0, async (r2) => {
-  try {
-    return await t();
-  } catch (n) {
-    throw _optionalChain([e, 'optionalAccess', _3 => _3.shouldRetryError]) && !e.shouldRetryError(n) && r2(n), n;
+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();
+      } catch (error2) {
+        if (_optionalChain([opts, 'optionalAccess', _4 => _4.shouldRetryError]) && !opts.shouldRetryError(error2)) {
+          bail(error2);
+        }
+        throw error2;
+      }
+    },
+    _nullishCoalesce(opts, () => ( { retries: 0 }))
+  );
+};
+var ParseError = class extends Error {
+  constructor(text) {
+    super(`Cannot parse! ${text}`);
   }
-}, _nullishCoalesce(e, () => ( { retries: 0 })));
-var W = class extends Error {
-  constructor(e) {
-    super(`Cannot parse! ${e}`);
+};
+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
+    );
+  },
+  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;
   }
 };
-var c2 = { stringify: (t, e) => JSON.stringify(_optionalChain([e, 'optionalAccess', _4 => _4.map]) ? e.map(t) : t, (r2, n) => typeof n == "bigint" ? n.toString() : n), parse: (t, e) => {
-  let r2 = JSON.parse(t, _optionalChain([e, 'optionalAccess', _5 => _5.reviver]));
-  if (_optionalChain([e, 'optionalAccess', _6 => _6.typeCheck]) && !_optionalChain([e, 'optionalAccess', _7 => _7.typeCheck, 'call', _8 => _8(r2)])) throw new W(t);
-  return _optionalChain([e, 'optionalAccess', _9 => _9.map]) ? e.map(r2) : r2;
-} };
-var ae = (t) => new (0, _webstreamspolyfill.TransformStream)({ transform(e, r2) {
-  t(e) && r2.enqueue(e);
-} });
-var se = (t) => new (0, _webstreamspolyfill.TransformStream)({ transform(e, r2) {
-  r2.enqueue(t(e));
-} });
-var ie = (t, e) => new g2(t, e);
-var g2 = class extends _webstreamspolyfill.TransformStream {
+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(e, r2) {
-    super({ transform: (n) => {
-      this.accumulator = this.reducer(this.accumulator, n);
-    }, flush: (n) => {
-      n.enqueue(this.accumulator), n.terminate();
-    } }), this.accumulator = r2, this.reducer = e;
+  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 me = (t, e, r2 = { forever: true, minTimeout: 25 }) => new (0, _webstreamspolyfill.TransformStream)({ start(n) {
-  w2(() => Ne(t, e, n), r2).catch((o2) => {
-    n.error(o2);
-  });
-} });
-var Ne = async (t, e, r2) => {
-  let o2 = t().getReader();
+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 a2;
+    let done;
     do {
-      let i = await o2.read();
-      a2 = i.done, await e(i, r2), a2 && r2.terminate();
-    } while (!a2);
+      const result = await reader.read();
+      done = result.done;
+      await handleChunk2(result, controller);
+      if (done) {
+        controller.terminate();
+      }
+    } while (!done);
   } finally {
-    o2.releaseLock();
+    reader.releaseLock();
   }
 };
-var de = (t) => new h(t);
-var h = (_class2 = class extends _webstreamspolyfill.TransformStream {
+var skip = (limit) => new SkipTransformStream(limit);
+var SkipTransformStream = (_class2 = class extends _webstreamspolyfill.TransformStream {
   __init3() {this.count = 0}
   
-  constructor(e) {
-    super({ transform: (r2, n) => {
-      this.count++, this.count > this.skip && n.enqueue(r2);
-    } });_class2.prototype.__init3.call(this);, this.skip = e;
+  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 pe = (t) => new (0, _webstreamspolyfill.TransformStream)({ transform(e, r2) {
-  r2.enqueue(e), t(e) && r2.terminate();
-} });
-var le = (t) => new (0, _webstreamspolyfill.TransformStream)({ async transform(e, r2) {
-  if (!t(e)) {
-    r2.enqueue(e);
-    return;
+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();
   }
-  await Promise.resolve(), r2.terminate();
-} });
-var ce = (t) => new C(t);
-var C = (_class3 = class extends _webstreamspolyfill.TransformStream {
+});
+var take = (limit) => new TakeTransformStream(limit);
+var TakeTransformStream = (_class3 = class extends _webstreamspolyfill.TransformStream {
   __init4() {this.count = 0}
   
-  constructor(e) {
-    super({ transform: (r2, n) => {
-      this.count < this.limit ? (this.count++, n.enqueue(r2)) : n.terminate();
-    } });_class3.prototype.__init4.call(this);, this.limit = e;
+  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 ue = (t) => new (0, _webstreamspolyfill.TransformStream)({ start(e) {
-  let r2 = setTimeout(() => {
-    e.terminate();
-  }, t), n = e.terminate.bind(e);
-  e.terminate = () => {
-    clearTimeout(r2), n();
-  };
-}, transform(e, r2) {
-  r2.enqueue(e);
-} });
-var fe = { filter: ae, take: ce, TakeTransformStream: C, skip: de, SkipTransformStream: h, map: se, notifyAboutNoActiveReadersStream: O, NotifyAboutNoActiveReadersStream: S, reduce: ie, ReduceTransformStream: g2, retry: me, stopAfter: pe, stopOn: le, waitAtMost: ue };
-var { retry: Be } = fe;
-var p2 = class extends Error {
-  constructor(e) {
-    super(e);
+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;
+var AssertionError = class extends Error {
+  constructor(message) {
+    super(message);
   }
 };
-var ye = (t, e) => {
-  let r2 = t, n = e;
-  return U(r2), U(n), Object.keys(n).every((o2) => typeof n[o2] == "object" ? ye(r2[o2], n[o2]) : n[o2] === r2[o2]);
+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 po = (t) => {
-  throw new p2(_nullishCoalesce(t, () => ( "That should not ever happened, right?")));
+var assertFails = (message) => {
+  throw new AssertionError(_nullishCoalesce(message, () => ( "That should not ever happened, right?")));
 };
-var ve = (t, e, r2) => {
-  if (!ye(t, e)) throw new p2(_nullishCoalesce(r2, () => ( `subObj:
-${c2.stringify(e)}
+var assertMatches = (actual, expected, message) => {
+  if (!isSubset(actual, expected))
+    throw new AssertionError(
+      _nullishCoalesce(message, () => ( `subObj:
+${JSONParser.stringify(expected)}
 is not subset of
-${c2.stringify(t)}`)));
+${JSONParser.stringify(actual)}`))
+    );
 };
-function U(t, e) {
-  if (!t) throw new p2(_nullishCoalesce(e, () => ( "Condition is not truthy")));
+function assertOk(obj, message) {
+  if (!obj) throw new AssertionError(_nullishCoalesce(message, () => ( `Condition is not truthy`)));
 }
-function u(t, e, r2) {
-  if (t !== e) throw new p2(`${_nullishCoalesce(r2, () => ( "Objects are not equal"))}:
-Expected: ${c2.stringify(t)}
-Actual:${c2.stringify(e)}`);
+function assertEqual(expected, actual, message) {
+  if (expected !== actual)
+    throw new AssertionError(
+      `${_nullishCoalesce(message, () => ( "Objects are not equal"))}:
+Expected: ${JSONParser.stringify(expected)}
+Actual:${JSONParser.stringify(actual)}`
+    );
 }
-var wo = (t) => {
-  let e = /* @__PURE__ */ new Map();
-  return { async aggregateStream(r2, n) {
-    return t.aggregateStream(r2, n);
-  }, readStream(r2, n) {
-    return t.readStream(r2, n);
-  }, appendToStream: async (r2, n, o2) => {
-    let a2 = await t.appendToStream(r2, n, o2), i = _nullishCoalesce(e.get(r2), () => ( [r2, []]));
-    return e.set(r2, [r2, [...i[1], ...n]]), a2;
-  }, appendedEvents: e, setup: async (r2, n) => t.appendToStream(r2, n) };
+var WrapEventStore = (eventStore) => {
+  const appendedEvents = /* @__PURE__ */ new Map();
+  return {
+    async aggregateStream(streamName, options) {
+      return eventStore.aggregateStream(streamName, options);
+    },
+    readStream(streamName, options) {
+      return 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();
+    // },
+  };
 };
 
 // src/middlewares/problemDetailsMiddleware.ts
@@ -197,7 +330,7 @@ var problemDetailsMiddleware = (mapError) => (error, request, response, _next) =
 };
 var defaulErrorToProblemDetailsMapping = (error) => {
   let statusCode = 500;
-  if ("errorCode" in error && s(error.errorCode) && error.errorCode >= 100 && error.errorCode < 600) {
+  if ("errorCode" in error && isNumber(error.errorCode) && error.errorCode >= 100 && error.errorCode < 600) {
     statusCode = error.errorCode;
   }
   return new (0, _httpproblemdetails.ProblemDocument)({
@@ -364,7 +497,7 @@ var ApiE2ESpecification = {
   for: (getEventStore, getApplication2) => {
     {
       return (...givenRequests) => {
-        const eventStore = wo(getEventStore());
+        const eventStore = WrapEventStore(getEventStore());
         const application = getApplication2(eventStore);
         return {
           when: (setupRequest) => {
@@ -404,9 +537,9 @@ var expectNewEvents = (streamId, events) => {
 };
 var expectResponse = (statusCode, options) => (response) => {
   const { body, headers } = _nullishCoalesce(options, () => ( {}));
-  u(statusCode, response.statusCode, "Response code doesn't match");
-  if (body) ve(response.body, body);
-  if (headers) ve(response.headers, headers);
+  assertEqual(statusCode, response.statusCode, "Response code doesn't match");
+  if (body) assertMatches(response.body, body);
+  if (headers) assertMatches(response.headers, headers);
 };
 var expectError = (errorCode, problemDetails) => expectResponse(
   errorCode,
@@ -416,7 +549,7 @@ var ApiSpecification = {
   for: (getEventStore, getApplication2) => {
     {
       return (...givenStreams) => {
-        const eventStore = wo(getEventStore());
+        const eventStore = WrapEventStore(getEventStore());
         const application = getApplication2(eventStore);
         return {
           when: (setupRequest) => {
@@ -431,15 +564,15 @@ var ApiSpecification = {
                 const response = await handle();
                 if (typeof verify === "function") {
                   const succeeded = verify(response);
-                  if (succeeded === false) po();
+                  if (succeeded === false) assertFails();
                 } else if (Array.isArray(verify)) {
                   const [first, ...rest] = verify;
                   if (typeof first === "function") {
                     const succeeded = first(response);
-                    if (succeeded === false) po();
+                    if (succeeded === false) assertFails();
                   }
                   const events = typeof first === "function" ? rest : verify;
-                  ve(
+                  assertMatches(
                     Array.from(eventStore.appendedEvents.values()),
                     events
                   );