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

package/dist/index.cjs

@@ -3,24 +3,32 @@
 
 var _dumbo = require('@event-driven-io/dumbo');
 
-// ../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 = (t4) => typeof t4 == "number" && t4 === t4;
-var m = (t4) => typeof t4 == "string";
-var T = (t4) => typeof t4 == "function" && t4.prototype && t4.prototype.constructor === t4;
-var o = class t extends Error {
+// ../emmett/dist/chunk-AEEEXE2R.js
+var isNumber = (val) => typeof val === "number" && val === val;
+var isString = (val) => typeof val === "string";
+var isErrorConstructor = (expect) => {
+  return typeof expect === "function" && expect.prototype && // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+  expect.prototype.constructor === expect;
+};
+var EmmettError = class _EmmettError extends Error {
   
-  constructor(e) {
-    let i = e && typeof e == "object" && "errorCode" in e ? e.errorCode : s(e) ? e : 500, n = e && typeof e == "object" && "message" in e ? e.message : m(e) ? e : `Error with status code '${i}' ocurred during Emmett processing`;
-    super(n), this.errorCode = i, Object.setPrototypeOf(this, t.prototype);
+  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);
   }
 };
-var g = class t2 extends o {
-  constructor(i, n, u2) {
-    super({ errorCode: 412, message: _nullishCoalesce(u2, () => ( `Expected version ${n.toString()} does not match current ${_optionalChain([i, 'optionalAccess', _ => _.toString, 'call', _2 => _2()])}`)) });
-    this.current = i;
-    this.expected = n;
-    Object.setPrototypeOf(this, t2.prototype);
+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', _2 => _2.toString, 'call', _3 => _3()])}`))
+    });
+    this.current = current;
+    this.expected = expected;
+    Object.setPrototypeOf(this, _ConcurrencyError.prototype);
   }
 };
 
@@ -42,27 +50,48 @@ var _asyncretry = require('async-retry'); var _asyncretry2 = _interopRequireDefa
 
 
 
-var L = (t4, e, r2) => ({ type: t4, data: e, metadata: r2 });
-var xe = "STREAM_EXISTS";
-var F = "STREAM_DOES_NOT_EXIST";
-var D = "NO_CONCURRENCY_CHECK";
-var ge = (t4, e, r2) => e === D ? true : e == F ? t4 === r2 : e == xe ? t4 !== r2 : t4 === e;
-var N = (t4, e, r2) => {
-  if (e ??= D, !ge(t4, e, r2)) throw new b(t4, e);
+
+
+var event = (type, data, metadata) => {
+  return {
+    type,
+    data,
+    metadata
+  };
+};
+var STREAM_EXISTS = "STREAM_EXISTS";
+var STREAM_DOES_NOT_EXIST = "STREAM_DOES_NOT_EXIST";
+var NO_CONCURRENCY_CHECK = "NO_CONCURRENCY_CHECK";
+var matchesExpectedVersion = (current, expected, defaultVersion) => {
+  if (expected === NO_CONCURRENCY_CHECK) return true;
+  if (expected == STREAM_DOES_NOT_EXIST) return current === defaultVersion;
+  if (expected == STREAM_EXISTS) return current !== defaultVersion;
+  return current === expected;
 };
-var b = class t3 extends g {
-  constructor(e, r2) {
-    super(_optionalChain([e, 'optionalAccess', _3 => _3.toString, 'call', _4 => _4()]), _optionalChain([r2, 'optionalAccess', _5 => _5.toString, 'call', _6 => _6()])), Object.setPrototypeOf(this, t3.prototype);
+var assertExpectedVersionMatchesCurrent = (current, expected, defaultVersion) => {
+  expected ??= NO_CONCURRENCY_CHECK;
+  if (!matchesExpectedVersion(current, expected, defaultVersion))
+    throw new ExpectedVersionConflictError(current, expected);
+};
+var ExpectedVersionConflictError = class _ExpectedVersionConflictError extends ConcurrencyError {
+  constructor(current, expected) {
+    super(_optionalChain([current, 'optionalAccess', _4 => _4.toString, 'call', _5 => _5()]), _optionalChain([expected, 'optionalAccess', _6 => _6.toString, 'call', _7 => _7()]));
+    Object.setPrototypeOf(this, _ExpectedVersionConflictError.prototype);
   }
 };
-var O = (t4, e = {}) => new S(t4, 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', _7 => _7.streamId]), () => ( _uuid.v4.call(void 0, ))), this.onNoActiveReaderCallback = r2, this.startChecking(_nullishCoalesce(_optionalChain([n, 'optionalAccess', _8 => _8.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', _8 => _8.streamId]), () => ( _uuid.v4.call(void 0, )));
+    this.onNoActiveReaderCallback = onNoActiveReaderCallback;
+    this.startChecking(_nullishCoalesce(_optionalChain([options, 'optionalAccess', _9 => _9.intervalCheckInMs]), () => ( 20)));
   }
   __init() {this.checkInterval = null}
   
@@ -70,182 +99,322 @@ 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 d2 = (t4, e) => {
-  if (Oe(t4)) return t4.equals(e);
-  if (Array.isArray(t4)) return Array.isArray(e) && t4.length === e.length && t4.every((o2, a2) => d2(o2, e[a2]));
-  if (typeof t4 != "object" || typeof e != "object" || t4 === null || e === null) return t4 === e;
-  if (Array.isArray(e)) return false;
-  let r2 = Object.keys(t4), n = Object.keys(e);
-  if (r2.length !== n.length || !r2.every((o2) => n.includes(o2))) return false;
-  for (let o2 in t4) {
-    if (t4[o2] instanceof Function && e[o2] instanceof Function) continue;
-    if (!d2(t4[o2], e[o2])) return false;
+var deepEquals = (left, right) => {
+  if (isEquatable(left)) {
+    return left.equals(right);
+  }
+  if (Array.isArray(left)) {
+    return Array.isArray(right) && left.length === right.length && left.every((val, index) => deepEquals(val, right[index]));
+  }
+  if (typeof left !== "object" || typeof right !== "object" || left === null || right === null) {
+    return left === right;
+  }
+  if (Array.isArray(right)) return false;
+  const keys1 = Object.keys(left);
+  const keys2 = Object.keys(right);
+  if (keys1.length !== keys2.length || !keys1.every((key) => keys2.includes(key)))
+    return false;
+  for (const key in left) {
+    if (left[key] instanceof Function && right[key] instanceof Function)
+      continue;
+    const isEqual = deepEquals(left[key], right[key]);
+    if (!isEqual) {
+      return false;
+    }
   }
   return true;
 };
-var Oe = (t4) => t4 && typeof t4 == "object" && "equals" in t4 && typeof t4.equals == "function";
-var w2 = async (t4, e) => e === void 0 || e.retries === 0 ? t4() : _asyncretry2.default.call(void 0, async (r2) => {
-  try {
-    return await t4();
-  } catch (n) {
-    throw _optionalChain([e, 'optionalAccess', _9 => _9.shouldRetryError]) && !e.shouldRetryError(n) && r2(n), n;
+var isEquatable = (left) => {
+  return left && typeof left === "object" && "equals" in left && typeof left["equals"] === "function";
+};
+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', _10 => _10.shouldRetryError]) && !opts.shouldRetryError(error2)) {
+          bail(error2);
+        }
+        throw error2;
+      }
+    },
+    _nullishCoalesce(opts, () => ( { retries: 0 }))
+  );
+};
+var projection = (definition) => definition;
+var ParseError = class extends Error {
+  constructor(text) {
+    super(`Cannot parse! ${text}`);
   }
-}, _nullishCoalesce(e, () => ( { retries: 0 })));
-var Wr = (t4) => t4;
-var W = class extends Error {
-  constructor(e) {
-    super(`Cannot parse! ${e}`);
+};
+var JSONParser = {
+  stringify: (value, options) => {
+    return JSON.stringify(
+      _optionalChain([options, 'optionalAccess', _11 => _11.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', _12 => _12.reviver]));
+    if (_optionalChain([options, 'optionalAccess', _13 => _13.typeCheck]) && !_optionalChain([options, 'optionalAccess', _14 => _14.typeCheck, 'call', _15 => _15(parsed)]))
+      throw new ParseError(text);
+    return _optionalChain([options, 'optionalAccess', _16 => _16.map]) ? options.map(parsed) : parsed;
   }
 };
-var c2 = { stringify: (t4, e) => JSON.stringify(_optionalChain([e, 'optionalAccess', _10 => _10.map]) ? e.map(t4) : t4, (r2, n) => typeof n == "bigint" ? n.toString() : n), parse: (t4, e) => {
-  let r2 = JSON.parse(t4, _optionalChain([e, 'optionalAccess', _11 => _11.reviver]));
-  if (_optionalChain([e, 'optionalAccess', _12 => _12.typeCheck]) && !_optionalChain([e, 'optionalAccess', _13 => _13.typeCheck, 'call', _14 => _14(r2)])) throw new W(t4);
-  return _optionalChain([e, 'optionalAccess', _15 => _15.map]) ? e.map(r2) : r2;
-} };
-var ae = (t4) => new (0, _webstreamspolyfill.TransformStream)({ transform(e, r2) {
-  t4(e) && r2.enqueue(e);
-} });
-var se = (t4) => new (0, _webstreamspolyfill.TransformStream)({ transform(e, r2) {
-  r2.enqueue(t4(e));
-} });
-var ie = (t4, e) => new g2(t4, 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 = (t4, e, r2 = { forever: true, minTimeout: 25 }) => new (0, _webstreamspolyfill.TransformStream)({ start(n) {
-  w2(() => Ne(t4, e, n), r2).catch((o2) => {
-    n.error(o2);
-  });
-} });
-var Ne = async (t4, e, r2) => {
-  let o2 = t4().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 = (t4) => new h(t4);
-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 = (t4) => new (0, _webstreamspolyfill.TransformStream)({ transform(e, r2) {
-  r2.enqueue(e), t4(e) && r2.terminate();
-} });
-var le = (t4) => new (0, _webstreamspolyfill.TransformStream)({ async transform(e, r2) {
-  if (!t4(e)) {
-    r2.enqueue(e);
-    return;
+var stopAfter = (stopCondition) => new (0, _webstreamspolyfill.TransformStream)({
+  transform(chunk, controller) {
+    controller.enqueue(chunk);
+    if (stopCondition(chunk)) {
+      controller.terminate();
+    }
   }
-  await Promise.resolve(), r2.terminate();
-} });
-var ce = (t4) => new C(t4);
-var C = (_class3 = class extends _webstreamspolyfill.TransformStream {
+});
+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(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 = (t4) => new (0, _webstreamspolyfill.TransformStream)({ start(e) {
-  let r2 = setTimeout(() => {
-    e.terminate();
-  }, t4), 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 po = (t4) => {
-  throw new p2(_nullishCoalesce(t4, () => ( "That should not ever happened, right?")));
+var { retry: retry2 } = streamTransformations;
+var AssertionError = class extends Error {
+  constructor(message) {
+    super(message);
+  }
+};
+var assertFails = (message) => {
+  throw new AssertionError(_nullishCoalesce(message, () => ( "That should not ever happened, right?")));
 };
-var Ke = (t4, e, r2) => {
-  if (!d2(t4, e)) throw new p2(_nullishCoalesce(r2, () => ( `subObj:
-${c2.stringify(e)}
+var assertDeepEqual = (actual, expected, message) => {
+  if (!deepEquals(actual, expected))
+    throw new AssertionError(
+      _nullishCoalesce(message, () => ( `subObj:
+${JSONParser.stringify(expected)}
 is not equal to
-${c2.stringify(t4)}`)));
+${JSONParser.stringify(actual)}`))
+    );
 };
-function s2(t4, e) {
-  if (!t4) throw new p2(_nullishCoalesce(e, () => ( "Condition is false")));
+function assertTrue(condition, message) {
+  if (!condition) throw new AssertionError(_nullishCoalesce(message, () => ( `Condition is false`)));
 }
-function U(t4, e) {
-  if (!t4) 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(t4, e, r2) {
-  if (t4 !== e) throw new p2(`${_nullishCoalesce(r2, () => ( "Objects are not equal"))}:
-Expected: ${c2.stringify(t4)}
-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)}`
+    );
 }
-function Ee(t4, e, r2) {
-  if (t4 === e) throw new p2(_nullishCoalesce(r2, () => ( `Objects are equal: ${c2.stringify(t4)}`)));
+function assertNotEqual(obj, other, message) {
+  if (obj === other)
+    throw new AssertionError(
+      _nullishCoalesce(message, () => ( `Objects are equal: ${JSONParser.stringify(obj)}`))
+    );
 }
-function vo(t4) {
-  Ee(t4, null), U(t4);
+function assertIsNotNull(result) {
+  assertNotEqual(result, null);
+  assertOk(result);
 }
-var go = (t4) => ({ isEmpty: () => u(t4.length, 0), isNotEmpty: () => Ee(t4.length, 0), hasSize: (e) => u(t4.length, e), containsElements: (...e) => {
-  s2(e.every((r2) => e.some((n) => d2(r2, n))));
-}, containsExactlyInAnyOrder: (...e) => {
-  u(t4.length, e.length), s2(t4.every((r2) => e.some((n) => d2(r2, n))));
-}, containsExactlyInAnyOrderElementsOf: (e) => {
-  u(t4.length, e.length), s2(t4.every((r2) => e.some((n) => d2(r2, n))));
-}, containsExactlyElementsOf: (e) => {
-  u(t4.length, e.length);
-  for (let r2 = 0; r2 < t4.length; r2++) s2(d2(t4[r2], e[r2]));
-}, containsExactly: (e) => {
-  u(t4.length, 1), s2(d2(t4[0], e));
-}, contains: (e) => {
-  s2(t4.some((r2) => d2(r2, e)));
-}, containsOnlyOnceElementsOf: (e) => {
-  s2(e.map((r2) => t4.filter((n) => d2(n, r2)).length).filter((r2) => r2 === 1).length === e.length);
-}, containsAnyOf: (...e) => {
-  s2(t4.some((r2) => e.some((n) => d2(r2, n))));
-}, allMatch: (e) => {
-  s2(t4.every(e));
-}, anyMatches: (e) => {
-  s2(t4.some(e));
-}, allMatchAsync: async (e) => {
-  for (let r2 of t4) s2(await e(r2));
-} });
+var assertThatArray = (array) => {
+  return {
+    isEmpty: () => assertEqual(array.length, 0),
+    isNotEmpty: () => assertNotEqual(array.length, 0),
+    hasSize: (length) => assertEqual(array.length, length),
+    containsElements: (...other) => {
+      assertTrue(other.every((ts) => other.some((o) => deepEquals(ts, o))));
+    },
+    containsExactlyInAnyOrder: (...other) => {
+      assertEqual(array.length, other.length);
+      assertTrue(array.every((ts) => other.some((o) => deepEquals(ts, o))));
+    },
+    containsExactlyInAnyOrderElementsOf: (other) => {
+      assertEqual(array.length, other.length);
+      assertTrue(array.every((ts) => other.some((o) => deepEquals(ts, o))));
+    },
+    containsExactlyElementsOf: (other) => {
+      assertEqual(array.length, other.length);
+      for (let i = 0; i < array.length; i++) {
+        assertTrue(deepEquals(array[i], other[i]));
+      }
+    },
+    containsExactly: (elem) => {
+      assertEqual(array.length, 1);
+      assertTrue(deepEquals(array[0], elem));
+    },
+    contains: (elem) => {
+      assertTrue(array.some((a) => deepEquals(a, elem)));
+    },
+    containsOnlyOnceElementsOf: (other) => {
+      assertTrue(
+        other.map((o) => array.filter((a) => deepEquals(a, o)).length).filter((a) => a === 1).length === other.length
+      );
+    },
+    containsAnyOf: (...other) => {
+      assertTrue(array.some((a) => other.some((o) => deepEquals(a, o))));
+    },
+    allMatch: (matches) => {
+      assertTrue(array.every(matches));
+    },
+    anyMatches: (matches) => {
+      assertTrue(array.some(matches));
+    },
+    allMatchAsync: async (matches) => {
+      for (const item of array) {
+        assertTrue(await matches(item));
+      }
+    }
+  };
+};
 
 // src/eventStore/postgreSQLEventStore.ts
 require('pg');
@@ -278,13 +447,13 @@ var withoutIdAndVersion = (doc) => {
 };
 var assertDocumentsEqual = (actual, expected) => {
   if ("_id" in expected)
-    u(
+    assertEqual(
       expected._id,
       actual._id,
       // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
       `Document ids are not matching! Expected: ${expected._id}, actual: ${actual._id}`
     );
-  return Ke(
+  return assertDeepEqual(
     withoutIdAndVersion(actual),
     withoutIdAndVersion(expected)
   );
@@ -294,7 +463,7 @@ var documentExists = (document, options) => (assertOptions) => withCollection(
     const result = await collection.findOne(
       "withId" in options ? { _id: options.withId } : options.matchingFilter
     );
-    vo(result);
+    assertIsNotNull(result);
     assertDocumentsEqual(result, document);
   },
   { ...options, ...assertOptions }
@@ -304,13 +473,13 @@ var documentsAreTheSame = (documents, options) => (assertOptions) => withCollect
     const result = await collection.find(
       "withId" in options ? { _id: options.withId } : options.matchingFilter
     );
-    u(
+    assertEqual(
       documents.length,
       result.length,
       "Different Documents Count than expected"
     );
     for (let i = 0; i < documents.length; i++) {
-      go(result).contains(documents[i]);
+      assertThatArray(result).contains(documents[i]);
     }
   },
   { ...options, ...assertOptions }
@@ -320,7 +489,7 @@ var documentsMatchingHaveCount = (expectedCount, options) => (assertOptions) =>
     const result = await collection.find(
       "withId" in options ? { _id: options.withId } : options.matchingFilter
     );
-    u(
+    assertEqual(
       expectedCount,
       result.length,
       "Different Documents Count than expected"
@@ -333,7 +502,7 @@ var documentMatchingExists = (options) => (assertOptions) => withCollection(
     const result = await collection.find(
       "withId" in options ? { _id: options.withId } : options.matchingFilter
     );
-    go(result).isNotEmpty();
+    assertThatArray(result).isNotEmpty();
   },
   { ...options, ...assertOptions }
 );
@@ -342,7 +511,7 @@ var documentDoesNotExist = (options) => (assertOptions) => withCollection(
     const result = await collection.findOne(
       "withId" in options ? { _id: options.withId } : options.matchingFilter
     );
-    vo(result);
+    assertIsNotNull(result);
   },
   { ...options, ...assertOptions }
 );
@@ -365,22 +534,22 @@ var expectPongoDocuments = {
           })
         };
       },
-      matching: (filter) => {
+      matching: (filter2) => {
         return {
           toBeTheSame: (documents) => documentsAreTheSame(documents, {
-            matchingFilter: filter,
+            matchingFilter: filter2,
             inCollection: collectionName
           }),
           toHaveCount: (expectedCount) => documentsMatchingHaveCount(expectedCount, {
-            matchingFilter: filter,
+            matchingFilter: filter2,
             inCollection: collectionName
           }),
           toExist: () => documentMatchingExists({
-            matchingFilter: filter,
+            matchingFilter: filter2,
             inCollection: collectionName
           }),
           notToExist: () => documentDoesNotExist({
-            matchingFilter: filter,
+            matchingFilter: filter2,
             inCollection: collectionName
           })
         };
@@ -414,14 +583,14 @@ var pongoMultiStreamProjection = (options) => {
   return pongoProjection({
     handle: async (events, { pongo }) => {
       const collection = pongo.db().collection(collectionName);
-      for (const event of events) {
-        await collection.handle(getDocumentId(event), async (document) => {
+      for (const event2 of events) {
+        await collection.handle(getDocumentId(event2), async (document) => {
           return "initialState" in options ? await options.evolve(
             _nullishCoalesce(document, () => ( options.initialState())),
-            event
+            event2
           ) : await options.evolve(
             document,
-            event
+            event2
           );
         });
       }
@@ -432,7 +601,7 @@ var pongoMultiStreamProjection = (options) => {
 var pongoSingleStreamProjection = (options) => {
   return pongoMultiStreamProjection({
     ...options,
-    getDocumentId: (event) => event.metadata.streamName
+    getDocumentId: (event2) => event2.metadata.streamName
   });
 };
 
@@ -444,7 +613,7 @@ var pongoSingleStreamProjection = (options) => {
 var PostgreSQLProjectionSpec = {
   for: (options) => {
     {
-      const { projection, ...dumoOptions } = options;
+      const { projection: projection2, ...dumoOptions } = options;
       const { connectionString } = dumoOptions;
       return (givenEvents) => {
         return {
@@ -452,13 +621,13 @@ var PostgreSQLProjectionSpec = {
             const allEvents = [];
             const run = async (pool) => {
               let globalPosition = 0n;
-              const numberOfTimes = _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _16 => _16.numberOfTimes]), () => ( 1));
-              for (const event of [
+              const numberOfTimes = _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _17 => _17.numberOfTimes]), () => ( 1));
+              for (const event2 of [
                 ...givenEvents,
                 ...Array.from({ length: numberOfTimes }).flatMap(() => events)
               ]) {
                 allEvents.push({
-                  ...event,
+                  ...event2,
                   metadata: {
                     ...{
                       globalPosition: ++globalPosition,
@@ -466,14 +635,14 @@ var PostgreSQLProjectionSpec = {
                       streamName: `test-${_uuid.v4.call(void 0, )}`,
                       eventId: _uuid.v4.call(void 0, )
                     },
-                    ..._nullishCoalesce(event.metadata, () => ( {}))
+                    ..._nullishCoalesce(event2.metadata, () => ( {}))
                   }
                 });
               }
               await pool.withTransaction(
                 (transaction) => handleProjections({
                   events: allEvents,
-                  projections: [projection],
+                  projections: [projection2],
                   connection: {
                     connectionString,
                     transaction
@@ -488,7 +657,7 @@ var PostgreSQLProjectionSpec = {
                   await run(pool);
                   const succeeded = await assert({ pool, connectionString });
                   if (succeeded !== void 0 && succeeded === false)
-                    po(
+                    assertFails(
                       _nullishCoalesce(message, () => ( "Projection specification didn't match the criteria"))
                     );
                 } finally {
@@ -499,25 +668,25 @@ var PostgreSQLProjectionSpec = {
                 const pool = _dumbo.dumbo.call(void 0, dumoOptions);
                 try {
                   await run(pool);
-                  throw new p2("Handler did not fail as expected");
+                  throw new AssertionError("Handler did not fail as expected");
                 } catch (error) {
-                  if (error instanceof p2) throw error;
+                  if (error instanceof AssertionError) throw error;
                   if (args.length === 0) return;
-                  if (!T(args[0])) {
-                    s2(
+                  if (!isErrorConstructor(args[0])) {
+                    assertTrue(
                       args[0](error),
-                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _17 => _17.toString, 'call', _18 => _18()])}`
+                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _18 => _18.toString, 'call', _19 => _19()])}`
                     );
                     return;
                   }
-                  s2(
+                  assertTrue(
                     error instanceof args[0],
-                    `Caught error is not an instance of the expected type: ${_optionalChain([error, 'optionalAccess', _19 => _19.toString, 'call', _20 => _20()])}`
+                    `Caught error is not an instance of the expected type: ${_optionalChain([error, 'optionalAccess', _20 => _20.toString, 'call', _21 => _21()])}`
                   );
                   if (args[1]) {
-                    s2(
+                    assertTrue(
                       args[1](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', _22 => _22.toString, 'call', _23 => _23()])}`
                     );
                   }
                 } finally {
@@ -531,12 +700,12 @@ var PostgreSQLProjectionSpec = {
     }
   }
 };
-var eventInStream = (streamName, event) => {
+var eventInStream = (streamName, event2) => {
   return {
-    ...event,
+    ...event2,
     metadata: {
-      ..._nullishCoalesce(event.metadata, () => ( {})),
-      streamName: _nullishCoalesce(_optionalChain([event, 'access', _23 => _23.metadata, 'optionalAccess', _24 => _24.streamName]), () => ( streamName))
+      ..._nullishCoalesce(event2.metadata, () => ( {})),
+      streamName: _nullishCoalesce(_optionalChain([event2, 'access', _24 => _24.metadata, 'optionalAccess', _25 => _25.streamName]), () => ( streamName))
     }
   };
 };
@@ -546,7 +715,7 @@ var eventsInStream = (streamName, events) => {
 var newEventsInStream = eventsInStream;
 var assertSQLQueryResultMatches = (sql3, rows) => async ({ pool: { execute } }) => {
   const result = await execute.query(sql3);
-  go(rows).containsExactlyInAnyOrder(...result.rows);
+  assertThatArray(rows).containsExactlyInAnyOrder(...result.rows);
 };
 var expectSQL = {
   query: (sql3) => ({
@@ -565,11 +734,11 @@ var handleProjections = async (options) => {
   } = options;
   const eventTypes = events.map((e) => e.type);
   const projections = allProjections.filter(
-    (p3) => p3.canHandle.some((type) => eventTypes.includes(type))
+    (p) => p.canHandle.some((type) => eventTypes.includes(type))
   );
   const client = await transaction.connection.open();
-  for (const projection of projections) {
-    await projection.handle(events, {
+  for (const projection2 of projections) {
+    await projection2.handle(events, {
       connectionString,
       client,
       transaction,
@@ -577,7 +746,7 @@ var handleProjections = async (options) => {
     });
   }
 };
-var postgreSQLProjection = (definition) => Wr(definition);
+var postgreSQLProjection = (definition) => projection(definition);
 var postgreSQLRawBatchSQLProjection = (handle, ...canHandle) => postgreSQLProjection({
   canHandle,
   handle: async (events, context) => {
@@ -588,8 +757,8 @@ var postgreSQLRawBatchSQLProjection = (handle, ...canHandle) => postgreSQLProjec
 var postgreSQLRawSQLProjection = (handle, ...canHandle) => postgreSQLRawBatchSQLProjection(
   async (events, context) => {
     const sqls = [];
-    for (const event of events) {
-      sqls.push(await handle(event, context));
+    for (const event2 of events) {
+      sqls.push(await handle(event2, context));
     }
     return sqls;
   },
@@ -729,7 +898,7 @@ var appendToStream = (pool, streamName, streamType, events, options) => pool.wit
   let appendResult;
   try {
     const expectedStreamVersion = toExpectedVersion(
-      _optionalChain([options, 'optionalAccess', _25 => _25.expectedStreamVersion])
+      _optionalChain([options, 'optionalAccess', _26 => _26.expectedStreamVersion])
     );
     const eventsToAppend = events.map((e, i) => ({
       ...e,
@@ -749,7 +918,7 @@ var appendToStream = (pool, streamName, streamType, events, options) => pool.wit
         expectedStreamVersion
       }
     );
-    if (_optionalChain([options, 'optionalAccess', _26 => _26.preCommitHook]))
+    if (_optionalChain([options, 'optionalAccess', _27 => _27.preCommitHook]))
       await options.preCommitHook(eventsToAppend, { transaction });
   } catch (error) {
     if (!isOptimisticConcurrencyError(error)) throw error;
@@ -778,9 +947,9 @@ var appendToStream = (pool, streamName, streamType, events, options) => pool.wit
 });
 var toExpectedVersion = (expected) => {
   if (expected === void 0) return null;
-  if (expected === D) return null;
-  if (expected == F) return null;
-  if (expected == xe) return null;
+  if (expected === NO_CONCURRENCY_CHECK) return null;
+  if (expected == STREAM_DOES_NOT_EXIST) return null;
+  if (expected == STREAM_EXISTS) return null;
   return expected;
 };
 var isOptimisticConcurrencyError = (error) => error instanceof Error && "code" in error && error.code === "23505";
@@ -799,14 +968,14 @@ var appendEventsRaw = (execute, streamId, streamType, events, options) => _dumbo
                   %L::text
               )`,
       events.map((e) => _dumbo.sql.call(void 0, "%L", e.metadata.eventId)).join(","),
-      events.map((e) => _dumbo.sql.call(void 0, "%L", c2.stringify(e.data))).join(","),
-      events.map((e) => _dumbo.sql.call(void 0, "%L", c2.stringify(_nullishCoalesce(e.metadata, () => ( {}))))).join(","),
+      events.map((e) => _dumbo.sql.call(void 0, "%L", JSONParser.stringify(e.data))).join(","),
+      events.map((e) => _dumbo.sql.call(void 0, "%L", JSONParser.stringify(_nullishCoalesce(e.metadata, () => ( {}))))).join(","),
       events.map(() => `'1'`).join(","),
       events.map((e) => _dumbo.sql.call(void 0, "%L", e.type)).join(","),
       streamId,
       streamType,
-      _nullishCoalesce(_optionalChain([options, 'optionalAccess', _27 => _27.expectedStreamVersion]), () => ( "NULL")),
-      _nullishCoalesce(_optionalChain([options, 'optionalAccess', _28 => _28.partition]), () => ( defaultTag))
+      _nullishCoalesce(_optionalChain([options, 'optionalAccess', _28 => _28.expectedStreamVersion]), () => ( "NULL")),
+      _nullishCoalesce(_optionalChain([options, 'optionalAccess', _29 => _29.partition]), () => ( defaultTag))
     )
   )
 );
@@ -1124,11 +1293,11 @@ var readStream = async (execute, streamId, options) => {
            FROM ${eventsTable.name}
            WHERE stream_id = %L AND partition = %L AND is_archived = FALSE ${fromCondition} ${toCondition}`,
         streamId,
-        _nullishCoalesce(_optionalChain([options, 'optionalAccess', _29 => _29.partition]), () => ( defaultTag))
+        _nullishCoalesce(_optionalChain([options, 'optionalAccess', _30 => _30.partition]), () => ( defaultTag))
       )
     ),
     (row) => {
-      const rawEvent = L(
+      const rawEvent = event(
         row.event_type,
         row.event_data,
         row.event_metadata
@@ -1188,7 +1357,7 @@ var getPostgreSQLEventStore = (connectionString, options = defaultPostgreSQLOpti
   };
   const pool = "dumbo" in poolOptions ? poolOptions.dumbo : _dumbo.dumbo.call(void 0, poolOptions);
   let migrateSchema;
-  const autoGenerateSchema = _optionalChain([options, 'access', _30 => _30.schema, 'optionalAccess', _31 => _31.autoMigration]) === void 0 || _optionalChain([options, 'access', _32 => _32.schema, 'optionalAccess', _33 => _33.autoMigration]) !== "None";
+  const autoGenerateSchema = _optionalChain([options, 'access', _31 => _31.schema, 'optionalAccess', _32 => _32.autoMigration]) === void 0 || _optionalChain([options, 'access', _33 => _33.schema, 'optionalAccess', _34 => _34.autoMigration]) !== "None";
   const ensureSchemaExists = () => {
     if (!autoGenerateSchema) return Promise.resolve();
     if (!migrateSchema) {
@@ -1196,7 +1365,7 @@ var getPostgreSQLEventStore = (connectionString, options = defaultPostgreSQLOpti
     }
     return migrateSchema;
   };
-  const inlineProjections = (_nullishCoalesce(options.projections, () => ( []))).filter(({ type }) => type === "inline").map(({ projection }) => projection);
+  const inlineProjections = (_nullishCoalesce(options.projections, () => ( []))).filter(({ type }) => type === "inline").map(({ projection: projection2 }) => projection2);
   const preCommitHook = inlineProjections.length > 0 ? (events, { transaction }) => handleProjections({
     projections: inlineProjections,
     connection: {
@@ -1215,18 +1384,18 @@ var getPostgreSQLEventStore = (connectionString, options = defaultPostgreSQLOpti
     },
     async aggregateStream(streamName, options2) {
       const { evolve, initialState, read } = options2;
-      const expectedStreamVersion = _optionalChain([read, 'optionalAccess', _34 => _34.expectedStreamVersion]);
+      const expectedStreamVersion = _optionalChain([read, 'optionalAccess', _35 => _35.expectedStreamVersion]);
       let state = initialState();
       const result = await this.readStream(streamName, options2.read);
       const currentStreamVersion = result.currentStreamVersion;
-      N(
+      assertExpectedVersionMatchesCurrent(
         currentStreamVersion,
         expectedStreamVersion,
         PostgreSQLEventStoreDefaultStreamVersion
       );
-      for (const event of result.events) {
-        if (!event) continue;
-        state = evolve(state, event);
+      for (const event2 of result.events) {
+        if (!event2) continue;
+        state = evolve(state, event2);
       }
       return {
         currentStreamVersion,
@@ -1253,10 +1422,10 @@ var getPostgreSQLEventStore = (connectionString, options = defaultPostgreSQLOpti
         }
       );
       if (!appendResult.success)
-        throw new b(
+        throw new ExpectedVersionConflictError(
           -1n,
           //TODO: Return actual version in case of error
-          _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _35 => _35.expectedStreamVersion]), () => ( D))
+          _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _36 => _36.expectedStreamVersion]), () => ( NO_CONCURRENCY_CHECK))
         );
       return {
         nextExpectedStreamVersion: appendResult.nextStreamPosition,