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

package/dist/index.cjs

@@ -1,813 +1,9 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3;// src/eventStore/postgreSQLEventStore.ts
-
-
-var _dumbo = require('@event-driven-io/dumbo');
-
-// ../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(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 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);
-  }
-};
-
-// ../emmett/dist/index.js
-var _uuid = require('uuid');
-var _webstreamspolyfill = require('web-streams-polyfill');
-
-
-
-var _asyncretry = require('async-retry'); var _asyncretry2 = _interopRequireDefault(_asyncretry);
-
-
-
-
-
-
-
-
-
-
-
-
-
-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 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 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}
-  
-  __init2() {this._isStopped = false}
-  get hasActiveSubscribers() {
-    return !this._isStopped;
-  }
-  startChecking(interval) {
-    this.checkInterval = setInterval(() => {
-      this.checkNoActiveReader();
-    }, interval);
-  }
-  stopChecking() {
-    if (!this.checkInterval) return;
-    clearInterval(this.checkInterval);
-    this.checkInterval = null;
-    this._isStopped = true;
-    this.onNoActiveReaderCallback(this);
-  }
-  checkNoActiveReader() {
-    if (!this.readable.locked && !this._isStopped) {
-      this.stopChecking();
-    }
-  }
-}, _class);
-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 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}`);
-  }
-};
-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 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(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 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 done;
-    do {
-      const result = await reader.read();
-      done = result.done;
-      await handleChunk2(result, controller);
-      if (done) {
-        controller.terminate();
-      }
-    } while (!done);
-  } finally {
-    reader.releaseLock();
-  }
-};
-var skip = (limit) => new SkipTransformStream(limit);
-var SkipTransformStream = (_class2 = class extends _webstreamspolyfill.TransformStream {
-  __init3() {this.count = 0}
-  
-  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 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();
-  }
-});
-var take = (limit) => new TakeTransformStream(limit);
-var TakeTransformStream = (_class3 = class extends _webstreamspolyfill.TransformStream {
-  __init4() {this.count = 0}
-  
-  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 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 assertFails = (message) => {
-  throw new AssertionError(_nullishCoalesce(message, () => ( "That should not ever happened, right?")));
-};
-var assertDeepEqual = (actual, expected, message) => {
-  if (!deepEquals(actual, expected))
-    throw new AssertionError(
-      _nullishCoalesce(message, () => ( `subObj:
-${JSONParser.stringify(expected)}
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3;var _dumbo = require('@event-driven-io/dumbo');var k=(e=>(e.NOT_A_NONEMPTY_STRING="NOT_A_NONEMPTY_STRING",e.NOT_A_POSITIVE_NUMBER="NOT_A_POSITIVE_NUMBER",e.NOT_AN_UNSIGNED_BIGINT="NOT_AN_UNSIGNED_BIGINT",e))(k||{}),W=e=>typeof e=="number"&&e===e,q=e=>typeof e=="string";var M=e=>typeof e=="function"&&e.prototype&&e.prototype.constructor===e,z=class H extends Error{constructor(t){let n=t&&typeof t=="object"&&"errorCode"in t?t.errorCode:W(t)?t:500,a=t&&typeof t=="object"&&"message"in t?t.message:q(t)?t:`Error with status code '${n}' ocurred during Emmett processing`;super(a),this.errorCode=n,Object.setPrototypeOf(this,H.prototype)}},Y=class J extends z{constructor(t,n,a){super({errorCode:412,message:_nullishCoalesce(a, () => (`Expected version ${n.toString()} does not match current ${_optionalChain([t, 'optionalAccess', _2 => _2.toString, 'call', _3 => _3()])}`))}),this.current=t,this.expected=n,Object.setPrototypeOf(this,J.prototype)}};var _uuid = require('uuid');var _webstreamspolyfill = require('web-streams-polyfill');var _asyncretry = require('async-retry'); var _asyncretry2 = _interopRequireDefault(_asyncretry);var K=(e,t,n)=>({type:e,data:t,metadata:n});var F="STREAM_EXISTS",U="STREAM_DOES_NOT_EXIST",N="NO_CONCURRENCY_CHECK",Ae=(e,t,n)=>t===N?!0:t==U?e===n:t==F?e!==n:e===t,Z=(e,t,n)=>{if(t??=N,!Ae(e,t,n))throw new $(e,t)},$=class ee extends Y{constructor(t,n){super(_optionalChain([t, 'optionalAccess', _4 => _4.toString, 'call', _5 => _5()]),_optionalChain([n, 'optionalAccess', _6 => _6.toString, 'call', _7 => _7()])),Object.setPrototypeOf(this,ee.prototype)}};var xe=(e,t={})=>new te(e,t),te= (_class =class extends _webstreamspolyfill.TransformStream{constructor(e,t={}){super({cancel:n=>{console.log("Stream was canceled. Reason:",n),this.stopChecking()}});_class.prototype.__init.call(this);_class.prototype.__init2.call(this);,this.onNoActiveReaderCallback=e,this.streamId=_nullishCoalesce(_optionalChain([t, 'optionalAccess', _8 => _8.streamId]), () => (_uuid.v4.call(void 0, ))),this.onNoActiveReaderCallback=e,this.startChecking(_nullishCoalesce(_optionalChain([t, 'optionalAccess', _9 => _9.intervalCheckInMs]), () => (20)))}__init() {this.checkInterval=null}__init2() {this._isStopped=!1}get hasActiveSubscribers(){return!this._isStopped}startChecking(e){this.checkInterval=setInterval(()=>{this.checkNoActiveReader()},e)}stopChecking(){this.checkInterval&&(clearInterval(this.checkInterval),this.checkInterval=null,this._isStopped=!0,this.onNoActiveReaderCallback(this))}checkNoActiveReader(){!this.readable.locked&&!this._isStopped&&this.stopChecking()}}, _class);var u=(e,t)=>{if(we(e))return e.equals(t);if(Array.isArray(e))return Array.isArray(t)&&e.length===t.length&&e.every((o,i)=>u(o,t[i]));if(typeof e!="object"||typeof t!="object"||e===null||t===null)return e===t;if(Array.isArray(t))return!1;let n=Object.keys(e),a=Object.keys(t);if(n.length!==a.length||!n.every(o=>a.includes(o)))return!1;for(let o in e)if(!(e[o]instanceof Function&&t[o]instanceof Function)&&!u(e[o],t[o]))return!1;return!0},we=e=>e&&typeof e=="object"&&"equals"in e&&typeof e.equals=="function";var be=async(e,t)=>t===void 0||t.retries===0?e():_asyncretry2.default.call(void 0, async n=>{try{return await e()}catch(a){throw _optionalChain([t, 'optionalAccess', _10 => _10.shouldRetryError])&&!t.shouldRetryError(a)&&n(a),a}},_nullishCoalesce(t, () => ({retries:0})));var ne=e=>e;var Me=class extends Error{constructor(e){super(`Cannot parse! ${e}`)}},h={stringify:(e,t)=>JSON.stringify(_optionalChain([t, 'optionalAccess', _11 => _11.map])?t.map(e):e,(n,a)=>typeof a=="bigint"?a.toString():a),parse:(e,t)=>{let n=JSON.parse(e,_optionalChain([t, 'optionalAccess', _12 => _12.reviver]));if(_optionalChain([t, 'optionalAccess', _13 => _13.typeCheck])&&!_optionalChain([t, 'optionalAccess', _14 => _14.typeCheck, 'call', _15 => _15(n)]))throw new Me(e);return _optionalChain([t, 'optionalAccess', _16 => _16.map])?t.map(n):n}};var Ue=e=>new (0, _webstreamspolyfill.TransformStream)({transform(t,n){e(t)&&n.enqueue(t)}}),je=e=>new (0, _webstreamspolyfill.TransformStream)({transform(t,n){n.enqueue(e(t))}}),Be=(e,t)=>new ae(e,t),ae=class extends _webstreamspolyfill.TransformStream{constructor(e,t){super({transform:n=>{this.accumulator=this.reducer(this.accumulator,n)},flush:n=>{n.enqueue(this.accumulator),n.terminate()}}),this.accumulator=t,this.reducer=e}},Ve=(e,t,n={forever:!0,minTimeout:25})=>new (0, _webstreamspolyfill.TransformStream)({start(a){be(()=>Ge(e,t,a),n).catch(o=>{a.error(o)})}}),Ge=async(e,t,n)=>{let a=e().getReader();try{let o;do{let i=await a.read();o=i.done,await t(i,n),o&&n.terminate()}while(!o)}finally{a.releaseLock()}},We=e=>new oe(e),oe= (_class2 =class extends _webstreamspolyfill.TransformStream{__init3() {this.count=0}constructor(e){super({transform:(t,n)=>{this.count++,this.count>this.skip&&n.enqueue(t)}});_class2.prototype.__init3.call(this);,this.skip=e}}, _class2),ze=e=>new (0, _webstreamspolyfill.TransformStream)({transform(t,n){n.enqueue(t),e(t)&&n.terminate()}}),Ye=e=>new (0, _webstreamspolyfill.TransformStream)({async transform(t,n){if(!e(t)){n.enqueue(t);return}await Promise.resolve(),n.terminate()}}),Ke=e=>new re(e),re= (_class3 =class extends _webstreamspolyfill.TransformStream{__init4() {this.count=0}constructor(e){super({transform:(t,n)=>{this.count<this.limit?(this.count++,n.enqueue(t)):n.terminate()}});_class3.prototype.__init4.call(this);,this.limit=e}}, _class3),et=e=>new (0, _webstreamspolyfill.TransformStream)({start(t){let n=setTimeout(()=>{t.terminate()},e),a=t.terminate.bind(t);t.terminate=()=>{clearTimeout(n),a()}},transform(t,n){n.enqueue(t)}}),tt={filter:Ue,take:Ke,TakeTransformStream:re,skip:We,SkipTransformStream:oe,map:je,notifyAboutNoActiveReadersStream:xe,NotifyAboutNoActiveReadersStream:te,reduce:Be,ReduceTransformStream:ae,retry:Ve,stopAfter:ze,stopOn:Ye,waitAtMost:et},{retry:rn}=tt;var f=class extends Error{constructor(e){super(e)}};var ie=e=>{throw new f(_nullishCoalesce(e, () => ("That should not ever happened, right?")))};var se=(e,t,n)=>{if(!u(e,t))throw new f(_nullishCoalesce(n, () => (`subObj:
+${h.stringify(t)}
 is not equal to
-${JSONParser.stringify(actual)}`))
-    );
-};
-function assertTrue(condition, message) {
-  if (!condition) throw new AssertionError(_nullishCoalesce(message, () => ( `Condition is false`)));
-}
-function assertOk(obj, message) {
-  if (!obj) throw new AssertionError(_nullishCoalesce(message, () => ( `Condition is not truthy`)));
-}
-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 assertNotEqual(obj, other, message) {
-  if (obj === other)
-    throw new AssertionError(
-      _nullishCoalesce(message, () => ( `Objects are equal: ${JSONParser.stringify(obj)}`))
-    );
-}
-function assertIsNotNull(result) {
-  assertNotEqual(result, null);
-  assertOk(result);
-}
-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');
-
-// src/eventStore/projections/index.ts
-
-
-// src/eventStore/projections/pongo/pongoProjectionSpec.ts
-
-
-
-var _pongo = require('@event-driven-io/pongo');
-var withCollection = (handle, options) => {
-  const { pool, connectionString, inDatabase, inCollection } = options;
-  return pool.withConnection(async (connection) => {
-    const pongo = _pongo.pongoClient.call(void 0, connectionString, {
-      connectionOptions: { connection }
-    });
-    try {
-      const collection = pongo.db(inDatabase).collection(inCollection);
-      return handle(collection);
-    } finally {
-      await pongo.close();
-    }
-  });
-};
-var withoutIdAndVersion = (doc) => {
-  const { _id, _version, ...without } = doc;
-  return without;
-};
-var assertDocumentsEqual = (actual, expected) => {
-  if ("_id" in expected)
-    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 assertDeepEqual(
-    withoutIdAndVersion(actual),
-    withoutIdAndVersion(expected)
-  );
-};
-var documentExists = (document, options) => (assertOptions) => withCollection(
-  async (collection) => {
-    const result = await collection.findOne(
-      "withId" in options ? { _id: options.withId } : options.matchingFilter
-    );
-    assertIsNotNull(result);
-    assertDocumentsEqual(result, document);
-  },
-  { ...options, ...assertOptions }
-);
-var documentsAreTheSame = (documents, options) => (assertOptions) => withCollection(
-  async (collection) => {
-    const result = await collection.find(
-      "withId" in options ? { _id: options.withId } : options.matchingFilter
-    );
-    assertEqual(
-      documents.length,
-      result.length,
-      "Different Documents Count than expected"
-    );
-    for (let i = 0; i < documents.length; i++) {
-      assertThatArray(result).contains(documents[i]);
-    }
-  },
-  { ...options, ...assertOptions }
-);
-var documentsMatchingHaveCount = (expectedCount, options) => (assertOptions) => withCollection(
-  async (collection) => {
-    const result = await collection.find(
-      "withId" in options ? { _id: options.withId } : options.matchingFilter
-    );
-    assertEqual(
-      expectedCount,
-      result.length,
-      "Different Documents Count than expected"
-    );
-  },
-  { ...options, ...assertOptions }
-);
-var documentMatchingExists = (options) => (assertOptions) => withCollection(
-  async (collection) => {
-    const result = await collection.find(
-      "withId" in options ? { _id: options.withId } : options.matchingFilter
-    );
-    assertThatArray(result).isNotEmpty();
-  },
-  { ...options, ...assertOptions }
-);
-var documentDoesNotExist = (options) => (assertOptions) => withCollection(
-  async (collection) => {
-    const result = await collection.findOne(
-      "withId" in options ? { _id: options.withId } : options.matchingFilter
-    );
-    assertIsNotNull(result);
-  },
-  { ...options, ...assertOptions }
-);
-var expectPongoDocuments = {
-  fromCollection: (collectionName) => {
-    return {
-      withId: (id) => {
-        return {
-          toBeEqual: (document) => documentExists(document, {
-            withId: id,
-            inCollection: collectionName
-          }),
-          toExist: () => documentMatchingExists({
-            withId: id,
-            inCollection: collectionName
-          }),
-          notToExist: () => documentDoesNotExist({
-            withId: id,
-            inCollection: collectionName
-          })
-        };
-      },
-      matching: (filter2) => {
-        return {
-          toBeTheSame: (documents) => documentsAreTheSame(documents, {
-            matchingFilter: filter2,
-            inCollection: collectionName
-          }),
-          toHaveCount: (expectedCount) => documentsMatchingHaveCount(expectedCount, {
-            matchingFilter: filter2,
-            inCollection: collectionName
-          }),
-          toExist: () => documentMatchingExists({
-            matchingFilter: filter2,
-            inCollection: collectionName
-          }),
-          notToExist: () => documentDoesNotExist({
-            matchingFilter: filter2,
-            inCollection: collectionName
-          })
-        };
-      }
-    };
-  }
-};
-
-// src/eventStore/projections/pongo/projections.ts
-
-
-
-var pongoProjection = ({
-  handle,
-  canHandle
-}) => postgreSQLProjection({
-  canHandle,
-  handle: async (events, context) => {
-    const { connectionString, client } = context;
-    const pongo = _pongo.pongoClient.call(void 0, connectionString, {
-      connectionOptions: { client }
-    });
-    await handle(events, {
-      ...context,
-      pongo
-    });
-  }
-});
-var pongoMultiStreamProjection = (options) => {
-  const { collectionName, getDocumentId, canHandle } = options;
-  return pongoProjection({
-    handle: async (events, { pongo }) => {
-      const collection = pongo.db().collection(collectionName);
-      for (const event2 of events) {
-        await collection.handle(getDocumentId(event2), async (document) => {
-          return "initialState" in options ? await options.evolve(
-            _nullishCoalesce(document, () => ( options.initialState())),
-            event2
-          ) : await options.evolve(
-            document,
-            event2
-          );
-        });
-      }
-    },
-    canHandle
-  });
-};
-var pongoSingleStreamProjection = (options) => {
-  return pongoMultiStreamProjection({
-    ...options,
-    getDocumentId: (event2) => event2.metadata.streamName
-  });
-};
-
-// src/eventStore/projections/postgresProjectionSpec.ts
-
-
-
-
-var PostgreSQLProjectionSpec = {
-  for: (options) => {
-    {
-      const { projection: projection2, ...dumoOptions } = options;
-      const { connectionString } = dumoOptions;
-      return (givenEvents) => {
-        return {
-          when: (events, options2) => {
-            const allEvents = [];
-            const run = async (pool) => {
-              let globalPosition = 0n;
-              const numberOfTimes = _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _17 => _17.numberOfTimes]), () => ( 1));
-              for (const event2 of [
-                ...givenEvents,
-                ...Array.from({ length: numberOfTimes }).flatMap(() => events)
-              ]) {
-                allEvents.push({
-                  ...event2,
-                  metadata: {
-                    ...{
-                      globalPosition: ++globalPosition,
-                      streamPosition: globalPosition,
-                      streamName: `test-${_uuid.v4.call(void 0, )}`,
-                      eventId: _uuid.v4.call(void 0, )
-                    },
-                    ..._nullishCoalesce(event2.metadata, () => ( {}))
-                  }
-                });
-              }
-              await pool.withTransaction(
-                (transaction) => handleProjections({
-                  events: allEvents,
-                  projections: [projection2],
-                  connection: {
-                    connectionString,
-                    transaction
-                  }
-                })
-              );
-            };
-            return {
-              then: async (assert, message) => {
-                const pool = _dumbo.dumbo.call(void 0, dumoOptions);
-                try {
-                  await run(pool);
-                  const succeeded = await assert({ pool, connectionString });
-                  if (succeeded !== void 0 && succeeded === false)
-                    assertFails(
-                      _nullishCoalesce(message, () => ( "Projection specification didn't match the criteria"))
-                    );
-                } finally {
-                  await pool.close();
-                }
-              },
-              thenThrows: async (...args) => {
-                const pool = _dumbo.dumbo.call(void 0, dumoOptions);
-                try {
-                  await run(pool);
-                  throw new AssertionError("Handler did not fail as expected");
-                } catch (error) {
-                  if (error instanceof AssertionError) throw error;
-                  if (args.length === 0) return;
-                  if (!isErrorConstructor(args[0])) {
-                    assertTrue(
-                      args[0](error),
-                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _18 => _18.toString, 'call', _19 => _19()])}`
-                    );
-                    return;
-                  }
-                  assertTrue(
-                    error instanceof args[0],
-                    `Caught error is not an instance of the expected type: ${_optionalChain([error, 'optionalAccess', _20 => _20.toString, 'call', _21 => _21()])}`
-                  );
-                  if (args[1]) {
-                    assertTrue(
-                      args[1](error),
-                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _22 => _22.toString, 'call', _23 => _23()])}`
-                    );
-                  }
-                } finally {
-                  await pool.close();
-                }
-              }
-            };
-          }
-        };
-      };
-    }
-  }
-};
-var eventInStream = (streamName, event2) => {
-  return {
-    ...event2,
-    metadata: {
-      ..._nullishCoalesce(event2.metadata, () => ( {})),
-      streamName: _nullishCoalesce(_optionalChain([event2, 'access', _24 => _24.metadata, 'optionalAccess', _25 => _25.streamName]), () => ( streamName))
-    }
-  };
-};
-var eventsInStream = (streamName, events) => {
-  return events.map((e) => eventInStream(streamName, e));
-};
-var newEventsInStream = eventsInStream;
-var assertSQLQueryResultMatches = (sql3, rows) => async ({ pool: { execute } }) => {
-  const result = await execute.query(sql3);
-  assertThatArray(rows).containsExactlyInAnyOrder(...result.rows);
-};
-var expectSQL = {
-  query: (sql3) => ({
-    resultRows: {
-      toBeTheSame: (rows) => assertSQLQueryResultMatches(sql3, rows)
-    }
-  })
-};
-
-// src/eventStore/projections/index.ts
-var handleProjections = async (options) => {
-  const {
-    projections: allProjections,
-    events,
-    connection: { transaction, connectionString }
-  } = options;
-  const eventTypes = events.map((e) => e.type);
-  const projections = allProjections.filter(
-    (p) => p.canHandle.some((type) => eventTypes.includes(type))
-  );
-  const client = await transaction.connection.open();
-  for (const projection2 of projections) {
-    await projection2.handle(events, {
-      connectionString,
-      client,
-      transaction,
-      execute: transaction.execute
-    });
-  }
-};
-var postgreSQLProjection = (definition) => projection(definition);
-var postgreSQLRawBatchSQLProjection = (handle, ...canHandle) => postgreSQLProjection({
-  canHandle,
-  handle: async (events, context) => {
-    const sqls = await handle(events, context);
-    await context.execute.batchCommand(sqls);
-  }
-});
-var postgreSQLRawSQLProjection = (handle, ...canHandle) => postgreSQLRawBatchSQLProjection(
-  async (events, context) => {
-    const sqls = [];
-    for (const event2 of events) {
-      sqls.push(await handle(event2, context));
-    }
-    return sqls;
-  },
-  ...canHandle
-);
-
-// src/eventStore/schema/index.ts
-
-
-// src/eventStore/schema/appendToStream.ts
-
-
-
-
-
-
-
-// src/eventStore/schema/typing.ts
-var emmettPrefix = "emt";
-var globalTag = "global";
-var defaultTag = "emt:default";
-var globalNames = {
-  module: `${emmettPrefix}:module:${globalTag}`,
-  tenant: `${emmettPrefix}:tenant:${globalTag}`
-};
-var columns = {
-  partition: {
-    name: "partition"
-  },
-  isArchived: { name: "is_archived" }
-};
-var streamsTable = {
-  name: `${emmettPrefix}_streams`,
-  columns: {
-    partition: columns.partition,
-    isArchived: columns.isArchived
-  }
-};
-var eventsTable = {
-  name: `${emmettPrefix}_events`,
-  columns: {
-    partition: columns.partition,
-    isArchived: columns.isArchived
-  }
-};
-
-// src/eventStore/schema/appendToStream.ts
-var appendEventsSQL = _dumbo.rawSql.call(void 0, 
-  `CREATE OR REPLACE FUNCTION emt_append_event(
+${h.stringify(e)}`)))};function T(e,t){if(!e)throw new f(_nullishCoalesce(t, () => ("Condition is false")))}function nt(e,t){if(!e)throw new f(_nullishCoalesce(t, () => ("Condition is not truthy")))}function S(e,t,n){if(e!==t)throw new f(`${_nullishCoalesce(n, () => ("Objects are not equal"))}:
+Expected: ${h.stringify(e)}
+Actual:${h.stringify(t)}`)}function ce(e,t,n){if(e===t)throw new f(_nullishCoalesce(n, () => (`Objects are equal: ${h.stringify(e)}`)))}function j(e){ce(e,null),nt(e)}var R=e=>({isEmpty:()=>S(e.length,0),isNotEmpty:()=>ce(e.length,0),hasSize:t=>S(e.length,t),containsElements:(...t)=>{T(t.every(n=>t.some(a=>u(n,a))))},containsExactlyInAnyOrder:(...t)=>{S(e.length,t.length),T(e.every(n=>t.some(a=>u(n,a))))},containsExactlyInAnyOrderElementsOf:t=>{S(e.length,t.length),T(e.every(n=>t.some(a=>u(n,a))))},containsExactlyElementsOf:t=>{S(e.length,t.length);for(let n=0;n<e.length;n++)T(u(e[n],t[n]))},containsExactly:t=>{S(e.length,1),T(u(e[0],t))},contains:t=>{T(e.some(n=>u(n,t)))},containsOnlyOnceElementsOf:t=>{T(t.map(n=>e.filter(a=>u(a,n)).length).filter(n=>n===1).length===t.length)},containsAnyOf:(...t)=>{T(e.some(n=>t.some(a=>u(n,a))))},allMatch:t=>{T(e.every(t))},anyMatches:t=>{T(e.some(t))},allMatchAsync:async t=>{for(let n of e)T(await t(n))}});require('pg');var _pongo = require('@event-driven-io/pongo');var A=(e,t)=>{let{pool:n,connectionString:a,inDatabase:o,inCollection:i}=t;return n.withConnection(async p=>{let m=_pongo.pongoClient.call(void 0, a,{connectionOptions:{connection:p}});try{let E=m.db(o).collection(i);return e(E)}finally{await m.close()}})},me=e=>{let{_id:t,_version:n,...a}=e;return a},ot=(e,t)=>("_id"in t&&S(t._id,e._id,`Document ids are not matching! Expected: ${t._id}, actual: ${e._id}`),se(me(e),me(t))),rt= exports.documentExists =(e,t)=>n=>A(async a=>{let o=await a.findOne("withId"in t?{_id:t.withId}:t.matchingFilter);j(o),ot(o,e)},{...t,...n}),it= exports.documentsAreTheSame =(e,t)=>n=>A(async a=>{let o=await a.find("withId"in t?{_id:t.withId}:t.matchingFilter);S(e.length,o.length,"Different Documents Count than expected");for(let i=0;i<e.length;i++)R(o).contains(e[i])},{...t,...n}),st= exports.documentsMatchingHaveCount =(e,t)=>n=>A(async a=>{let o=await a.find("withId"in t?{_id:t.withId}:t.matchingFilter);S(e,o.length,"Different Documents Count than expected")},{...t,...n}),le= exports.documentMatchingExists =e=>t=>A(async n=>{let a=await n.find("withId"in e?{_id:e.withId}:e.matchingFilter);R(a).isNotEmpty()},{...e,...t}),de= exports.documentDoesNotExist =e=>t=>A(async n=>{let a=await n.findOne("withId"in e?{_id:e.withId}:e.matchingFilter);j(a)},{...e,...t}),gn= exports.expectPongoDocuments ={fromCollection:e=>({withId:t=>({toBeEqual:n=>rt(n,{withId:t,inCollection:e}),toExist:()=>le({withId:t,inCollection:e}),notToExist:()=>de({withId:t,inCollection:e})}),matching:t=>({toBeTheSame:n=>it(n,{matchingFilter:t,inCollection:e}),toHaveCount:n=>st(n,{matchingFilter:t,inCollection:e}),toExist:()=>le({matchingFilter:t,inCollection:e}),notToExist:()=>de({matchingFilter:t,inCollection:e})})})};var mt=({handle:e,canHandle:t})=>Q({canHandle:t,handle:async(n,a)=>{let{connectionString:o,client:i}=a,p=_pongo.pongoClient.call(void 0, o,{connectionOptions:{client:i}});await e(n,{...a,pongo:p})}}),lt= exports.pongoMultiStreamProjection =e=>{let{collectionName:t,getDocumentId:n,canHandle:a}=e;return mt({handle:async(o,{pongo:i})=>{let p=i.db().collection(t);for(let m of o)await p.handle(n(m),async E=>"initialState"in e?await e.evolve(_nullishCoalesce(E, () => (e.initialState())),m):await e.evolve(E,m))},canHandle:a})},Pn= exports.pongoSingleStreamProjection =e=>lt({...e,getDocumentId:t=>t.metadata.streamName});var wn={for:e=>{{let{projection:t,...n}=e,{connectionString:a}=n;return o=>({when:(i,p)=>{let m=[],E=async c=>{let d=0n,l=_nullishCoalesce(_optionalChain([p, 'optionalAccess', _17 => _17.numberOfTimes]), () => (1));for(let v of[...o,...Array.from({length:l}).flatMap(()=>i)])m.push({...v,metadata:{globalPosition:++d,streamPosition:d,streamName:`test-${_uuid.v4.call(void 0, )}`,eventId:_uuid.v4.call(void 0, ),..._nullishCoalesce(v.metadata, () => ({}))}});await c.withTransaction(v=>D({events:m,projections:[t],connection:{connectionString:a,transaction:v}}))};return{then:async(c,d)=>{let l=_dumbo.dumbo.call(void 0, n);try{await E(l);let v=await c({pool:l,connectionString:a});v!==void 0&&v===!1&&ie(_nullishCoalesce(d, () => ("Projection specification didn't match the criteria")))}finally{await l.close()}},thenThrows:async(...c)=>{let d=_dumbo.dumbo.call(void 0, n);try{throw await E(d),new f("Handler did not fail as expected")}catch(l){if(l instanceof f)throw l;if(c.length===0)return;if(!M(c[0])){T(c[0](l),`Error didn't match the error condition: ${_optionalChain([l, 'optionalAccess', _18 => _18.toString, 'call', _19 => _19()])}`);return}T(l instanceof c[0],`Caught error is not an instance of the expected type: ${_optionalChain([l, 'optionalAccess', _20 => _20.toString, 'call', _21 => _21()])}`),c[1]&&T(c[1](l),`Error didn't match the error condition: ${_optionalChain([l, 'optionalAccess', _22 => _22.toString, 'call', _23 => _23()])}`)}finally{await d.close()}}}}})}}},dt= exports.eventInStream =(e,t)=>({...t,metadata:{..._nullishCoalesce(t.metadata, () => ({})),streamName:_nullishCoalesce(_optionalChain([t, 'access', _24 => _24.metadata, 'optionalAccess', _25 => _25.streamName]), () => (e))}}),Et= exports.eventsInStream =(e,t)=>t.map(n=>dt(e,n)),Cn= exports.newEventsInStream =Et,pt= exports.assertSQLQueryResultMatches =(e,t)=>async({pool:{execute:n}})=>{let a=await n.query(e);R(t).containsExactlyInAnyOrder(...a.rows)},bn= exports.expectSQL ={query:e=>({resultRows:{toBeTheSame:t=>pt(e,t)}})};var D=async e=>{let{projections:t,events:n,connection:{transaction:a,connectionString:o}}=e,i=n.map(E=>E.type),p=t.filter(E=>E.canHandle.some(c=>i.includes(c))),m=await a.connection.open();for(let E of p)await E.handle(n,{connectionString:o,client:m,transaction:a,execute:a.execute})},Q= exports.postgreSQLProjection =e=>ne(e),vt= exports.postgreSQLRawBatchSQLProjection =(e,...t)=>Q({canHandle:t,handle:async(n,a)=>{let o=await e(n,a);await a.execute.batchCommand(o)}}),$n= exports.postgreSQLRawSQLProjection =(e,...t)=>vt(async(n,a)=>{let o=[];for(let i of n)o.push(await e(i,a));return o},...t);var x="emt",_= exports.globalTag ="global",O= exports.defaultTag ="emt:default",Xn= exports.globalNames ={module:`${x}:module:${_}`,tenant:`${x}:tenant:${_}`},w={partition:{name:"partition"},isArchived:{name:"is_archived"}},s= exports.streamsTable ={name:`${x}_streams`,columns:{partition:w.partition,isArchived:w.isArchived}},r= exports.eventsTable ={name:`${x}_events`,columns:{partition:w.partition,isArchived:w.isArchived}};var ve=_dumbo.rawSql.call(void 0, `CREATE OR REPLACE FUNCTION emt_append_event(
       v_event_ids text[],
       v_events_data jsonb[],
       v_events_metadata jsonb[],
@@ -833,7 +29,7 @@ var appendEventsSQL = _dumbo.rawSql.call(void 0,
   BEGIN
       IF v_expected_stream_position IS NULL THEN
           SELECT COALESCE(max(stream_position), 0) INTO v_expected_stream_position
-          FROM ${streamsTable.name}
+          FROM ${s.name}
           WHERE stream_id = v_stream_id AND partition = v_partition;
       END IF;
 
@@ -855,7 +51,7 @@ var appendEventsSQL = _dumbo.rawSql.call(void 0,
           ) AS event
       ),
       all_events_insert AS (
-          INSERT INTO ${eventsTable.name}
+          INSERT INTO ${r.name}
               (stream_id, stream_position, partition, event_data, event_metadata, event_schema_version, event_type, event_id, transaction_id)
           SELECT 
               v_stream_id, ev.stream_position, v_partition, ev.event_data, ev.event_metadata, ev.schema_version, ev.event_type, ev.event_id, v_transaction_id
@@ -869,12 +65,12 @@ var appendEventsSQL = _dumbo.rawSql.call(void 0,
 
 
       IF v_expected_stream_position = 0 THEN
-          INSERT INTO ${streamsTable.name}
+          INSERT INTO ${s.name}
               (stream_id, stream_position, partition, stream_type, stream_metadata, is_archived)
           VALUES
               (v_stream_id, v_next_stream_position, v_partition, v_stream_type, '{}', FALSE);
       ELSE
-          UPDATE ${streamsTable.name} as s              
+          UPDATE ${s.name} as s              
           SET stream_position = v_next_stream_position
           WHERE stream_id = v_stream_id AND stream_position = v_expected_stream_position AND partition = v_partition AND is_archived = FALSE;
 
@@ -889,74 +85,7 @@ var appendEventsSQL = _dumbo.rawSql.call(void 0,
       RETURN QUERY SELECT TRUE, v_next_stream_position, v_last_global_position, v_transaction_id;
   END;
   $$;
-  `
-);
-var appendToStream = (pool, streamName, streamType, events, options) => pool.withTransaction(async (transaction) => {
-  const { execute } = transaction;
-  if (events.length === 0)
-    return { success: false, result: { success: false } };
-  let appendResult;
-  try {
-    const expectedStreamVersion = toExpectedVersion(
-      _optionalChain([options, 'optionalAccess', _26 => _26.expectedStreamVersion])
-    );
-    const eventsToAppend = events.map((e, i) => ({
-      ...e,
-      metadata: {
-        streamName,
-        eventId: _uuid.v4.call(void 0, ),
-        streamPosition: BigInt(i),
-        ...e.metadata
-      }
-    }));
-    appendResult = await appendEventsRaw(
-      execute,
-      streamName,
-      streamType,
-      eventsToAppend,
-      {
-        expectedStreamVersion
-      }
-    );
-    if (_optionalChain([options, 'optionalAccess', _27 => _27.preCommitHook]))
-      await options.preCommitHook(eventsToAppend, { transaction });
-  } catch (error) {
-    if (!isOptimisticConcurrencyError(error)) throw error;
-    appendResult = {
-      success: false,
-      last_global_position: null,
-      next_stream_position: null,
-      transaction_id: null
-    };
-  }
-  const {
-    success,
-    next_stream_position,
-    last_global_position,
-    transaction_id
-  } = appendResult;
-  return {
-    success,
-    result: success && next_stream_position && last_global_position && transaction_id ? {
-      success: true,
-      nextStreamPosition: BigInt(next_stream_position),
-      lastGlobalPosition: BigInt(last_global_position),
-      transactionId: transaction_id
-    } : { success: false }
-  };
-});
-var toExpectedVersion = (expected) => {
-  if (expected === void 0) 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";
-var appendEventsRaw = (execute, streamId, streamType, events, options) => _dumbo.single.call(void 0, 
-  execute.command(
-    _dumbo.sql.call(void 0, 
-      `SELECT * FROM emt_append_event(
+  `),_e= exports.appendToStream =(e,t,n,a,o)=>e.withTransaction(async i=>{let{execute:p}=i;if(a.length===0)return{success:!1,result:{success:!1}};let m;try{let v=gt(_optionalChain([o, 'optionalAccess', _26 => _26.expectedStreamVersion])),P=a.map((I,y)=>({...I,metadata:{streamName:t,eventId:_uuid.v4.call(void 0, ),streamPosition:BigInt(y),...I.metadata}}));m=await yt(p,t,n,P,{expectedStreamVersion:v}),_optionalChain([o, 'optionalAccess', _27 => _27.preCommitHook])&&await o.preCommitHook(P,{transaction:i})}catch(v){if(!St(v))throw v;m={success:!1,last_global_position:null,next_stream_position:null,transaction_id:null}}let{success:E,next_stream_position:c,last_global_position:d,transaction_id:l}=m;return{success:E,result:E&&c&&d&&l?{success:!0,nextStreamPosition:BigInt(c),lastGlobalPosition:BigInt(d),transactionId:l}:{success:!1}}}),gt=e=>e===void 0||e===N||e==U||e==F?null:e,St=e=>e instanceof Error&&"code"in e&&e.code==="23505",yt=(e,t,n,a,o)=>_dumbo.single.call(void 0, e.command(_dumbo.sql.call(void 0, `SELECT * FROM emt_append_event(
                   ARRAY[%s]::text[],
                   ARRAY[%s]::jsonb[],
                   ARRAY[%s]::jsonb[],
@@ -966,42 +95,22 @@ var appendEventsRaw = (execute, streamId, streamType, events, options) => _dumbo
                   %L::text,
                   %s::bigint,
                   %L::text
-              )`,
-      events.map((e) => _dumbo.sql.call(void 0, "%L", e.metadata.eventId)).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', _28 => _28.expectedStreamVersion]), () => ( "NULL")),
-      _nullishCoalesce(_optionalChain([options, 'optionalAccess', _29 => _29.partition]), () => ( defaultTag))
-    )
-  )
-);
-
-// src/eventStore/schema/tables.ts
-
-var streamsTableSQL = _dumbo.rawSql.call(void 0, 
-  `CREATE TABLE IF NOT EXISTS ${streamsTable.name}(
+              )`,a.map(i=>_dumbo.sql.call(void 0, "%L",i.metadata.eventId)).join(","),a.map(i=>_dumbo.sql.call(void 0, "%L",h.stringify(i.data))).join(","),a.map(i=>_dumbo.sql.call(void 0, "%L",h.stringify(_nullishCoalesce(i.metadata, () => ({}))))).join(","),a.map(()=>"'1'").join(","),a.map(i=>_dumbo.sql.call(void 0, "%L",i.type)).join(","),t,n,_nullishCoalesce(_optionalChain([o, 'optionalAccess', _28 => _28.expectedStreamVersion]), () => ("NULL")),_nullishCoalesce(_optionalChain([o, 'optionalAccess', _29 => _29.partition]), () => (O)))));var Te=_dumbo.rawSql.call(void 0, `CREATE TABLE IF NOT EXISTS ${s.name}(
       stream_id         TEXT                      NOT NULL,
       stream_position   BIGINT                    NOT NULL,
-      partition         TEXT                      NOT NULL DEFAULT '${globalTag}__${globalTag}',
+      partition         TEXT                      NOT NULL DEFAULT '${_}__${_}',
       stream_type       TEXT                      NOT NULL,
       stream_metadata   JSONB                     NOT NULL,
       is_archived       BOOLEAN                   NOT NULL DEFAULT FALSE,
       PRIMARY KEY (stream_id, stream_position, partition, is_archived),
       UNIQUE (stream_id, partition, is_archived)
-  ) PARTITION BY LIST (partition);`
-);
-var eventsTableSQL = _dumbo.rawSql.call(void 0, 
-  `
+  ) PARTITION BY LIST (partition);`),ue= exports.eventsTableSQL =_dumbo.rawSql.call(void 0, `
   CREATE SEQUENCE IF NOT EXISTS emt_global_event_position;
 
-  CREATE TABLE IF NOT EXISTS ${eventsTable.name}(
+  CREATE TABLE IF NOT EXISTS ${r.name}(
       stream_id              TEXT                      NOT NULL,
       stream_position        BIGINT                    NOT NULL,
-      partition              TEXT                      NOT NULL DEFAULT '${globalTag}',
+      partition              TEXT                      NOT NULL DEFAULT '${_}',
       event_data             JSONB                     NOT NULL,
       event_metadata         JSONB                     NOT NULL,
       event_schema_version   TEXT                      NOT NULL,
@@ -1012,10 +121,7 @@ var eventsTableSQL = _dumbo.rawSql.call(void 0,
       transaction_id         XID8                      NOT NULL,
       created                TIMESTAMPTZ               NOT NULL DEFAULT now(),
       PRIMARY KEY (stream_id, stream_position, partition, is_archived)
-  ) PARTITION BY LIST (partition);`
-);
-var subscriptionsTableSQL = _dumbo.rawSql.call(void 0, 
-  `
+  ) PARTITION BY LIST (partition);`),ge= exports.subscriptionsTableSQL =_dumbo.rawSql.call(void 0, `
   CREATE TABLE IF NOT EXISTS emt_subscriptions(
       subscription_id                 TEXT                   NOT NULL PRIMARY KEY,
       version                         INT                    NOT NULL DEFAULT 1,
@@ -1024,17 +130,11 @@ var subscriptionsTableSQL = _dumbo.rawSql.call(void 0,
       last_processed_position         BIGINT                 NOT NULL,
       last_processed_transaction_id   BIGINT                 NOT NULL
   );
-`
-);
-var sanitizeNameSQL = _dumbo.rawSql.call(void 0, 
-  `CREATE OR REPLACE FUNCTION emt_sanitize_name(input_name TEXT) RETURNS TEXT AS $$
+`),Se= exports.sanitizeNameSQL =_dumbo.rawSql.call(void 0, `CREATE OR REPLACE FUNCTION emt_sanitize_name(input_name TEXT) RETURNS TEXT AS $$
     BEGIN
         RETURN REGEXP_REPLACE(input_name, '[^a-zA-Z0-9_]', '_', 'g');
     END;
-    $$ LANGUAGE plpgsql;`
-);
-var addTablePartitions = _dumbo.rawSql.call(void 0, 
-  `
+    $$ LANGUAGE plpgsql;`),ye= exports.addTablePartitions =_dumbo.rawSql.call(void 0, `
   CREATE OR REPLACE FUNCTION emt_add_table_partition(tableName TEXT, partition_name TEXT) RETURNS void AS $$
   DECLARE
     v_main_partiton_name     TEXT;
@@ -1071,432 +171,193 @@ var addTablePartitions = _dumbo.rawSql.call(void 0,
           v_archived_partiton_name, v_main_partiton_name
       );
   END;
-  $$ LANGUAGE plpgsql;`
-);
-var addEventsPartitions = _dumbo.rawSql.call(void 0, 
-  `
+  $$ LANGUAGE plpgsql;`),fe= exports.addEventsPartitions =_dumbo.rawSql.call(void 0, `
   CREATE OR REPLACE FUNCTION emt_add_partition(partition_name TEXT) RETURNS void AS $$
   BEGIN                
-      PERFORM emt_add_table_partition('${eventsTable.name}', partition_name);
-      PERFORM emt_add_table_partition('${streamsTable.name}', partition_name);
+      PERFORM emt_add_table_partition('${r.name}', partition_name);
+      PERFORM emt_add_table_partition('${s.name}', partition_name);
   END;
-  $$ LANGUAGE plpgsql;`
-);
-var addModuleSQL = _dumbo.rawSql.call(void 0, 
-  `
+  $$ LANGUAGE plpgsql;`),he= exports.addModuleSQL =_dumbo.rawSql.call(void 0, `
       CREATE OR REPLACE FUNCTION add_module(new_module TEXT) RETURNS void AS $$
       BEGIN
-          -- For ${eventsTable.name} table
+          -- For ${r.name} table
           EXECUTE format('
               CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
               FOR VALUES IN (emt_sanitize_name(%L || ''__'' || %L)) PARTITION BY LIST (is_archived);',
-              emt_sanitize_name('${eventsTable.name}_' || new_module || '__' || '${globalTag}'), '${eventsTable.name}', new_module, '${globalTag}'
+              emt_sanitize_name('${r.name}_' || new_module || '__' || '${_}'), '${r.name}', new_module, '${_}'
           );
   
           EXECUTE format('
               CREATE TABLE IF NOT EXISTS %I_active PARTITION OF %I
               FOR VALUES IN (FALSE);',
-              emt_sanitize_name('${eventsTable.name}_' || new_module || '__' || '${globalTag}' || '_active'), emt_sanitize_name('${eventsTable.name}_' || new_module || '__' || '${globalTag}')
+              emt_sanitize_name('${r.name}_' || new_module || '__' || '${_}' || '_active'), emt_sanitize_name('${r.name}_' || new_module || '__' || '${_}')
           );
   
           EXECUTE format('
               CREATE TABLE IF NOT EXISTS %I_archived PARTITION OF %I
               FOR VALUES IN (TRUE);',
-              emt_sanitize_name('${eventsTable.name}_' || new_module || '__' || '${globalTag}' || '_archived'), emt_sanitize_name('${eventsTable.name}_' || new_module || '__' || '${globalTag}')
+              emt_sanitize_name('${r.name}_' || new_module || '__' || '${_}' || '_archived'), emt_sanitize_name('${r.name}_' || new_module || '__' || '${_}')
           );
   
-          -- For ${streamsTable.name} table
+          -- For ${s.name} table
           EXECUTE format('
               CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
               FOR VALUES IN (emt_sanitize_name(%L || ''__'' || %L)) PARTITION BY LIST (is_archived);',
-              emt_sanitize_name('${streamsTable.name}_' || new_module || '__' || '${globalTag}'), '${streamsTable.name}', new_module, '${globalTag}'
+              emt_sanitize_name('${s.name}_' || new_module || '__' || '${_}'), '${s.name}', new_module, '${_}'
           );
   
           EXECUTE format('
               CREATE TABLE IF NOT EXISTS %I_active PARTITION OF %I
               FOR VALUES IN (FALSE);',
-              emt_sanitize_name('${streamsTable.name}_' || new_module || '__' || '${globalTag}' || '_active'), emt_sanitize_name('${streamsTable.name}_' || new_module || '__' || '${globalTag}')
+              emt_sanitize_name('${s.name}_' || new_module || '__' || '${_}' || '_active'), emt_sanitize_name('${s.name}_' || new_module || '__' || '${_}')
           );
   
           EXECUTE format('
               CREATE TABLE IF NOT EXISTS %I_archived PARTITION OF %I
               FOR VALUES IN (TRUE);',
-              emt_sanitize_name('${streamsTable.name}_' || new_module || '__' || '${globalTag}' || '_archived'), emt_sanitize_name('${streamsTable.name}_' || new_module || '__' || '${globalTag}')
+              emt_sanitize_name('${s.name}_' || new_module || '__' || '${_}' || '_archived'), emt_sanitize_name('${s.name}_' || new_module || '__' || '${_}')
           );
       END;
       $$ LANGUAGE plpgsql;
-    `
-);
-var addTenantSQL = _dumbo.rawSql.call(void 0, 
-  `
+    `),Pe= exports.addTenantSQL =_dumbo.rawSql.call(void 0, `
     CREATE OR REPLACE FUNCTION add_tenant(new_module TEXT, new_tenant TEXT) RETURNS void AS $$
     BEGIN
-        -- For ${eventsTable.name} table
+        -- For ${r.name} table
         EXECUTE format('
             CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
             FOR VALUES IN (emt_sanitize_name(''%s__%s'')) PARTITION BY LIST (is_archived);',
-            emt_sanitize_name('${eventsTable.name}_' || new_module || '__' || new_tenant), '${eventsTable.name}', new_module, new_tenant
+            emt_sanitize_name('${r.name}_' || new_module || '__' || new_tenant), '${r.name}', new_module, new_tenant
         );
   
         EXECUTE format('
             CREATE TABLE IF NOT EXISTS %I_active PARTITION OF %I
             FOR VALUES IN (FALSE);',
-            emt_sanitize_name('${eventsTable.name}_' || new_module || '__' || new_tenant || '_active'), emt_sanitize_name('${eventsTable.name}_' || new_module || '__' || new_tenant)
+            emt_sanitize_name('${r.name}_' || new_module || '__' || new_tenant || '_active'), emt_sanitize_name('${r.name}_' || new_module || '__' || new_tenant)
         );
   
         EXECUTE format('
             CREATE TABLE IF NOT EXISTS %I_archived PARTITION OF %I
             FOR VALUES IN (TRUE);',
-            emt_sanitize_name('${eventsTable.name}_' || new_module || '__' || new_tenant || '_archived'), emt_sanitize_name('${eventsTable.name}_' || new_module || '__' || new_tenant)
+            emt_sanitize_name('${r.name}_' || new_module || '__' || new_tenant || '_archived'), emt_sanitize_name('${r.name}_' || new_module || '__' || new_tenant)
         );
   
-        -- For ${streamsTable.name} table
+        -- For ${s.name} table
         EXECUTE format('
             CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
             FOR VALUES IN (emt_sanitize_name(''%s__%s'')) PARTITION BY LIST (is_archived);',
-            emt_sanitize_name('${streamsTable.name}_' || new_module || '__' || new_tenant), '${streamsTable.name}', new_module, new_tenant
+            emt_sanitize_name('${s.name}_' || new_module || '__' || new_tenant), '${s.name}', new_module, new_tenant
         );
   
         EXECUTE format('
             CREATE TABLE IF NOT EXISTS %I_active PARTITION OF %I
             FOR VALUES IN (FALSE);',
-            emt_sanitize_name('${streamsTable.name}_' || new_module || '__' || new_tenant || '_active'), emt_sanitize_name('${streamsTable.name}_' || new_module || '__' || new_tenant)
+            emt_sanitize_name('${s.name}_' || new_module || '__' || new_tenant || '_active'), emt_sanitize_name('${s.name}_' || new_module || '__' || new_tenant)
         );
   
         EXECUTE format('
             CREATE TABLE IF NOT EXISTS %I_archived PARTITION OF %I
             FOR VALUES IN (TRUE);',
-            emt_sanitize_name('${streamsTable.name}_' || new_module || '__' || new_tenant || '_archived'), emt_sanitize_name('${streamsTable.name}_' || new_module || '__' || new_tenant)
+            emt_sanitize_name('${s.name}_' || new_module || '__' || new_tenant || '_archived'), emt_sanitize_name('${s.name}_' || new_module || '__' || new_tenant)
         );
     END;
     $$ LANGUAGE plpgsql;
-  `
-);
-var addModuleForAllTenantsSQL = _dumbo.rawSql.call(void 0, 
-  `
+  `),Ie= exports.addModuleForAllTenantsSQL =_dumbo.rawSql.call(void 0, `
     CREATE OR REPLACE FUNCTION add_module_for_all_tenants(new_module TEXT) RETURNS void AS $$
     DECLARE
         tenant_record RECORD;
     BEGIN
         PERFORM add_module(new_module);
   
-        FOR tenant_record IN SELECT DISTINCT tenant FROM ${eventsTable.name}
+        FOR tenant_record IN SELECT DISTINCT tenant FROM ${r.name}
         LOOP
-            -- For ${eventsTable.name} table
+            -- For ${r.name} table
             EXECUTE format('
                 CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
                 FOR VALUES IN (emt_sanitize_name(''%s__%s'')) PARTITION BY LIST (is_archived);',
-                emt_sanitize_name('${eventsTable.name}_' || new_module || '__' || tenant_record.tenant), '${eventsTable.name}', new_module, tenant_record.tenant
+                emt_sanitize_name('${r.name}_' || new_module || '__' || tenant_record.tenant), '${r.name}', new_module, tenant_record.tenant
             );
   
             EXECUTE format('
                 CREATE TABLE IF NOT EXISTS %I_active PARTITION OF %I
                 FOR VALUES IN (FALSE);',
-                emt_sanitize_name('${eventsTable.name}_' || new_module || '__' || tenant_record.tenant || '_active'), emt_sanitize_name('${eventsTable.name}_' || new_module || '__' || tenant_record.tenant)
+                emt_sanitize_name('${r.name}_' || new_module || '__' || tenant_record.tenant || '_active'), emt_sanitize_name('${r.name}_' || new_module || '__' || tenant_record.tenant)
             );
   
             EXECUTE format('
                 CREATE TABLE IF NOT EXISTS %I_archived PARTITION OF %I
                 FOR VALUES IN (TRUE);',
-                emt_sanitize_name('${eventsTable.name}_' || new_module || '__' || tenant_record.tenant || '_archived'), emt_sanitize_name('${eventsTable.name}_' || new_module || '__' || tenant_record.tenant)
+                emt_sanitize_name('${r.name}_' || new_module || '__' || tenant_record.tenant || '_archived'), emt_sanitize_name('${r.name}_' || new_module || '__' || tenant_record.tenant)
             );
   
-            -- For ${streamsTable.name} table
+            -- For ${s.name} table
             EXECUTE format('
                 CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
                 FOR VALUES IN (emt_sanitize_name(''%s__%s'')) PARTITION BY LIST (is_archived);',
-                emt_sanitize_name('${streamsTable.name}_' || new_module || '__' || tenant_record.tenant), '${streamsTable.name}', new_module, tenant_record.tenant
+                emt_sanitize_name('${s.name}_' || new_module || '__' || tenant_record.tenant), '${s.name}', new_module, tenant_record.tenant
             );
   
             EXECUTE format('
                 CREATE TABLE IF NOT EXISTS %I_active PARTITION OF %I
                 FOR VALUES IN (FALSE);',
-                emt_sanitize_name('${streamsTable.name}_' || new_module || '__' || tenant_record.tenant || '_active'), emt_sanitize_name('${streamsTable.name}_' || new_module || '__' || tenant_record.tenant)
+                emt_sanitize_name('${s.name}_' || new_module || '__' || tenant_record.tenant || '_active'), emt_sanitize_name('${s.name}_' || new_module || '__' || tenant_record.tenant)
             );
   
             EXECUTE format('
                 CREATE TABLE IF NOT EXISTS %I_archived PARTITION OF %I
                 FOR VALUES IN (TRUE);',
-                emt_sanitize_name('${streamsTable.name}_' || new_module || '__' || tenant_record.tenant || '_archived'), emt_sanitize_name('${streamsTable.name}_' || new_module || '__' || tenant_record.tenant)
+                emt_sanitize_name('${s.name}_' || new_module || '__' || tenant_record.tenant || '_archived'), emt_sanitize_name('${s.name}_' || new_module || '__' || tenant_record.tenant)
             );
         END LOOP;
     END;
     $$ LANGUAGE plpgsql;
-  `
-);
-var addTenantForAllModulesSQL = _dumbo.rawSql.call(void 0, 
-  `
+  `),Ne= exports.addTenantForAllModulesSQL =_dumbo.rawSql.call(void 0, `
     CREATE OR REPLACE FUNCTION add_tenant_for_all_modules(new_tenant TEXT) RETURNS void AS $$
     DECLARE
         module_record RECORD;
     BEGIN
-        FOR module_record IN SELECT DISTINCT partitionname FROM pg_partman.part_config WHERE parent_table = '${eventsTable.name}'
+        FOR module_record IN SELECT DISTINCT partitionname FROM pg_partman.part_config WHERE parent_table = '${r.name}'
         LOOP
-            -- For ${eventsTable.name} table
+            -- For ${r.name} table
             EXECUTE format('
                 CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
                 FOR VALUES IN (emt_sanitize_name(''%s__%s'')) PARTITION BY LIST (is_archived);',
-                emt_sanitize_name('${eventsTable.name}_' || module_record.partitionname || '__' || new_tenant), '${eventsTable.name}', module_record.partitionname, new_tenant
+                emt_sanitize_name('${r.name}_' || module_record.partitionname || '__' || new_tenant), '${r.name}', module_record.partitionname, new_tenant
             );
   
             EXECUTE format('
                 CREATE TABLE IF NOT EXISTS %I_active PARTITION OF %I
                 FOR VALUES IN (FALSE);',
-                emt_sanitize_name('${eventsTable.name}_' || module_record.partitionname || '__' || new_tenant || '_active'), emt_sanitize_name('${eventsTable.name}_' || module_record.partitionname || '__' || new_tenant)
+                emt_sanitize_name('${r.name}_' || module_record.partitionname || '__' || new_tenant || '_active'), emt_sanitize_name('${r.name}_' || module_record.partitionname || '__' || new_tenant)
             );
   
             EXECUTE format('
                 CREATE TABLE IF NOT EXISTS %I_archived PARTITION OF %I
                 FOR VALUES IN (TRUE);',
-                emt_sanitize_name('${eventsTable.name}_' || module_record.partitionname || '__' || new_tenant || '_archived'), emt_sanitize_name('${eventsTable.name}_' || module_record.partitionname || '__' || new_tenant)
+                emt_sanitize_name('${r.name}_' || module_record.partitionname || '__' || new_tenant || '_archived'), emt_sanitize_name('${r.name}_' || module_record.partitionname || '__' || new_tenant)
             );
   
-            -- For ${streamsTable.name} table
+            -- For ${s.name} table
             EXECUTE format('
                 CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
                 FOR VALUES IN (emt_sanitize_name(''%s__%s'')) PARTITION BY LIST (is_archived);',
-                emt_sanitize_name('${streamsTable.name}_' || module_record.partitionname || '__' || new_tenant), '${streamsTable.name}', module_record.partitionname, new_tenant
+                emt_sanitize_name('${s.name}_' || module_record.partitionname || '__' || new_tenant), '${s.name}', module_record.partitionname, new_tenant
             );
   
             EXECUTE format('
                 CREATE TABLE IF NOT EXISTS %I_active PARTITION OF %I
                 FOR VALUES IN (FALSE);',
-                emt_sanitize_name('${streamsTable.name}_' || module_record.partitionname || '__' || new_tenant || '_active'), emt_sanitize_name('${streamsTable.name}_' || module_record.partitionname || '__' || new_tenant)
+                emt_sanitize_name('${s.name}_' || module_record.partitionname || '__' || new_tenant || '_active'), emt_sanitize_name('${s.name}_' || module_record.partitionname || '__' || new_tenant)
             );
   
             EXECUTE format('
                 CREATE TABLE IF NOT EXISTS %I_archived PARTITION OF %I
                 FOR VALUES IN (TRUE);',
-                emt_sanitize_name('${streamsTable.name}_' || module_record.partitionname || '__' || new_tenant || '_archived'), emt_sanitize_name('${streamsTable.name}_' || module_record.partitionname || '__' || new_tenant)
+                emt_sanitize_name('${s.name}_' || module_record.partitionname || '__' || new_tenant || '_archived'), emt_sanitize_name('${s.name}_' || module_record.partitionname || '__' || new_tenant)
             );
         END LOOP;
     END;
     $$ LANGUAGE plpgsql;
-  `
-);
-var addDefaultPartition = _dumbo.rawSql.call(void 0, 
-  `SELECT emt_add_partition('${defaultTag}');`
-);
-
-// src/eventStore/schema/readStream.ts
-
-var readStream = async (execute, streamId, options) => {
-  const fromCondition = options && "from" in options ? `AND stream_position >= ${options.from}` : "";
-  const to = Number(
-    options && "to" in options ? options.to : options && "maxCount" in options && options.maxCount ? options.from + options.maxCount : NaN
-  );
-  const toCondition = !isNaN(to) ? `AND stream_position <= ${to}` : "";
-  const events = await _dumbo.mapRows.call(void 0, 
-    execute.query(
-      _dumbo.sql.call(void 0, 
-        `SELECT stream_id, stream_position, global_position, event_data, event_metadata, event_schema_version, event_type, event_id
-           FROM ${eventsTable.name}
-           WHERE stream_id = %L AND partition = %L AND is_archived = FALSE ${fromCondition} ${toCondition}`,
-        streamId,
-        _nullishCoalesce(_optionalChain([options, 'optionalAccess', _30 => _30.partition]), () => ( defaultTag))
-      )
-    ),
-    (row) => {
-      const rawEvent = event(
-        row.event_type,
-        row.event_data,
-        row.event_metadata
-      );
-      return {
-        ...rawEvent,
-        metadata: {
-          ...rawEvent.metadata,
-          eventId: row.event_id,
-          streamName: streamId,
-          streamPosition: BigInt(row.stream_position),
-          globalPosition: BigInt(row.global_position)
-        }
-      };
-    }
-  );
-  return events.length > 0 ? {
-    currentStreamVersion: events[events.length - 1].metadata.streamPosition,
-    events,
-    streamExists: true
-  } : {
-    currentStreamVersion: PostgreSQLEventStoreDefaultStreamVersion,
-    events: [],
-    streamExists: false
-  };
-};
-
-// src/eventStore/schema/index.ts
-var schemaSQL = [
-  streamsTableSQL,
-  eventsTableSQL,
-  subscriptionsTableSQL,
-  sanitizeNameSQL,
-  addTablePartitions,
-  addEventsPartitions,
-  addModuleSQL,
-  addTenantSQL,
-  addModuleForAllTenantsSQL,
-  addTenantForAllModulesSQL,
-  appendEventsSQL,
-  addDefaultPartition
-];
-var createEventStoreSchema = async (pool) => {
-  await pool.withTransaction(({ execute }) => execute.batchCommand(schemaSQL));
-};
-
-// src/eventStore/postgreSQLEventStore.ts
-var defaultPostgreSQLOptions = {
-  projections: [],
-  schema: { autoMigration: "CreateOrUpdate" }
-};
-var PostgreSQLEventStoreDefaultStreamVersion = 0n;
-var getPostgreSQLEventStore = (connectionString, options = defaultPostgreSQLOptions) => {
-  const poolOptions = {
-    connectionString,
-    ...options.connectionOptions ? options.connectionOptions : {}
-  };
-  const pool = "dumbo" in poolOptions ? poolOptions.dumbo : _dumbo.dumbo.call(void 0, poolOptions);
-  let migrateSchema;
-  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) {
-      migrateSchema = createEventStoreSchema(pool);
-    }
-    return migrateSchema;
-  };
-  const inlineProjections = (_nullishCoalesce(options.projections, () => ( []))).filter(({ type }) => type === "inline").map(({ projection: projection2 }) => projection2);
-  const preCommitHook = inlineProjections.length > 0 ? (events, { transaction }) => handleProjections({
-    projections: inlineProjections,
-    connection: {
-      connectionString,
-      transaction
-    },
-    events
-  }) : void 0;
-  return {
-    schema: {
-      sql: () => schemaSQL.join(""),
-      print: () => console.log(schemaSQL.join("")),
-      migrate: async () => {
-        await (migrateSchema = createEventStoreSchema(pool));
-      }
-    },
-    async aggregateStream(streamName, options2) {
-      const { evolve, initialState, read } = options2;
-      const expectedStreamVersion = _optionalChain([read, 'optionalAccess', _35 => _35.expectedStreamVersion]);
-      let state = initialState();
-      const result = await this.readStream(streamName, options2.read);
-      const currentStreamVersion = result.currentStreamVersion;
-      assertExpectedVersionMatchesCurrent(
-        currentStreamVersion,
-        expectedStreamVersion,
-        PostgreSQLEventStoreDefaultStreamVersion
-      );
-      for (const event2 of result.events) {
-        if (!event2) continue;
-        state = evolve(state, event2);
-      }
-      return {
-        currentStreamVersion,
-        state,
-        streamExists: result.streamExists
-      };
-    },
-    readStream: async (streamName, options2) => {
-      await ensureSchemaExists();
-      return readStream(pool.execute, streamName, options2);
-    },
-    appendToStream: async (streamName, events, options2) => {
-      await ensureSchemaExists();
-      const [firstPart, ...rest] = streamName.split("-");
-      const streamType = firstPart && rest.length > 0 ? firstPart : "emt:unknown";
-      const appendResult = await appendToStream(
-        pool,
-        streamName,
-        streamType,
-        events,
-        {
-          ...options2,
-          preCommitHook
-        }
-      );
-      if (!appendResult.success)
-        throw new ExpectedVersionConflictError(
-          -1n,
-          //TODO: Return actual version in case of error
-          _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _36 => _36.expectedStreamVersion]), () => ( NO_CONCURRENCY_CHECK))
-        );
-      return {
-        nextExpectedStreamVersion: appendResult.nextStreamPosition,
-        createdNewStream: appendResult.nextStreamPosition >= BigInt(events.length)
-      };
-    },
-    close: () => pool.close(),
-    async withSession(callback) {
-      return await pool.withConnection(async (connection) => {
-        const storeOptions = {
-          ...options,
-          connectionOptions: {
-            connection
-          }
-        };
-        const eventStore = getPostgreSQLEventStore(
-          connectionString,
-          storeOptions
-        );
-        return callback({
-          eventStore,
-          close: () => Promise.resolve()
-        });
-      });
-    }
-  };
-};
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-exports.PostgreSQLEventStoreDefaultStreamVersion = PostgreSQLEventStoreDefaultStreamVersion; exports.PostgreSQLProjectionSpec = PostgreSQLProjectionSpec; exports.addDefaultPartition = addDefaultPartition; exports.addEventsPartitions = addEventsPartitions; exports.addModuleForAllTenantsSQL = addModuleForAllTenantsSQL; exports.addModuleSQL = addModuleSQL; exports.addTablePartitions = addTablePartitions; exports.addTenantForAllModulesSQL = addTenantForAllModulesSQL; exports.addTenantSQL = addTenantSQL; exports.appendEventsSQL = appendEventsSQL; exports.appendToStream = appendToStream; exports.assertSQLQueryResultMatches = assertSQLQueryResultMatches; exports.createEventStoreSchema = createEventStoreSchema; exports.defaultPostgreSQLOptions = defaultPostgreSQLOptions; exports.defaultTag = defaultTag; exports.documentDoesNotExist = documentDoesNotExist; exports.documentExists = documentExists; exports.documentMatchingExists = documentMatchingExists; exports.documentsAreTheSame = documentsAreTheSame; exports.documentsMatchingHaveCount = documentsMatchingHaveCount; exports.emmettPrefix = emmettPrefix; exports.eventInStream = eventInStream; exports.eventsInStream = eventsInStream; exports.eventsTable = eventsTable; exports.eventsTableSQL = eventsTableSQL; exports.expectPongoDocuments = expectPongoDocuments; exports.expectSQL = expectSQL; exports.getPostgreSQLEventStore = getPostgreSQLEventStore; exports.globalNames = globalNames; exports.globalTag = globalTag; exports.handleProjections = handleProjections; exports.newEventsInStream = newEventsInStream; exports.pongoMultiStreamProjection = pongoMultiStreamProjection; exports.pongoProjection = pongoProjection; exports.pongoSingleStreamProjection = pongoSingleStreamProjection; exports.postgreSQLProjection = postgreSQLProjection; exports.postgreSQLRawBatchSQLProjection = postgreSQLRawBatchSQLProjection; exports.postgreSQLRawSQLProjection = postgreSQLRawSQLProjection; exports.readStream = readStream; exports.sanitizeNameSQL = sanitizeNameSQL; exports.schemaSQL = schemaSQL; exports.streamsTable = streamsTable; exports.streamsTableSQL = streamsTableSQL; exports.subscriptionsTableSQL = subscriptionsTableSQL;
+  `),Oe= exports.addDefaultPartition =_dumbo.rawSql.call(void 0, `SELECT emt_add_partition('${O}');`);var Re=async(e,t,n)=>{let a=n&&"from"in n?`AND stream_position >= ${n.from}`:"",o=Number(n&&"to"in n?n.to:n&&"maxCount"in n&&n.maxCount?n.from+n.maxCount:NaN),i=isNaN(o)?"":`AND stream_position <= ${o}`,p=await _dumbo.mapRows.call(void 0, e.query(_dumbo.sql.call(void 0, `SELECT stream_id, stream_position, global_position, event_data, event_metadata, event_schema_version, event_type, event_id
+           FROM ${r.name}
+           WHERE stream_id = %L AND partition = %L AND is_archived = FALSE ${a} ${i}`,t,_nullishCoalesce(_optionalChain([n, 'optionalAccess', _30 => _30.partition]), () => (O)))),m=>{let E=K(m.event_type,m.event_data,m.event_metadata);return{...E,metadata:{...E.metadata,eventId:m.event_id,streamName:t,streamPosition:BigInt(m.stream_position),globalPosition:BigInt(m.global_position)}}});return p.length>0?{currentStreamVersion:p[p.length-1].metadata.streamPosition,events:p,streamExists:!0}:{currentStreamVersion:B,events:[],streamExists:!1}};var C=[Te,ue,ge,Se,ye,fe,he,Pe,Ie,Ne,ve,Oe],X= exports.createEventStoreSchema =async e=>{await e.withTransaction(({execute:t})=>t.batchCommand(C))};var It={projections:[],schema:{autoMigration:"CreateOrUpdate"}},B= exports.PostgreSQLEventStoreDefaultStreamVersion =0n,Nt= exports.getPostgreSQLEventStore =(e,t=It)=>{let n={connectionString:e,...t.connectionOptions?t.connectionOptions:{}},a="dumbo"in n?n.dumbo:_dumbo.dumbo.call(void 0, n),o,i=_optionalChain([t, 'access', _31 => _31.schema, 'optionalAccess', _32 => _32.autoMigration])===void 0||_optionalChain([t, 'access', _33 => _33.schema, 'optionalAccess', _34 => _34.autoMigration])!=="None",p=()=>i?(o||(o=X(a)),o):Promise.resolve(),m=(_nullishCoalesce(t.projections, () => ([]))).filter(({type:c})=>c==="inline").map(({projection:c})=>c),E=m.length>0?(c,{transaction:d})=>D({projections:m,connection:{connectionString:e,transaction:d},events:c}):void 0;return{schema:{sql:()=>C.join(""),print:()=>console.log(C.join("")),migrate:async()=>{await(o=X(a))}},async aggregateStream(c,d){let{evolve:l,initialState:v,read:P}=d,I=_optionalChain([P, 'optionalAccess', _35 => _35.expectedStreamVersion]),y=v(),b=await this.readStream(c,d.read),V=b.currentStreamVersion;Z(V,I,B);for(let G of b.events)G&&(y=l(y,G));return{currentStreamVersion:V,state:y,streamExists:b.streamExists}},readStream:async(c,d)=>(await p(),Re(a.execute,c,d)),appendToStream:async(c,d,l)=>{await p();let[v,...P]=c.split("-"),I=v&&P.length>0?v:"emt:unknown",y=await _e(a,c,I,d,{...l,preCommitHook:E});if(!y.success)throw new $(-1n,_nullishCoalesce(_optionalChain([l, 'optionalAccess', _36 => _36.expectedStreamVersion]), () => (N)));return{nextExpectedStreamVersion:y.nextStreamPosition,createdNewStream:y.nextStreamPosition>=BigInt(d.length)}},close:()=>a.close(),async withSession(c){return await a.withConnection(async d=>{let l={...t,connectionOptions:{connection:d}},v=Nt(e,l);return c({eventStore:v,close:()=>Promise.resolve()})})}}};exports.PostgreSQLEventStoreDefaultStreamVersion = B; exports.PostgreSQLProjectionSpec = wn; exports.addDefaultPartition = Oe; exports.addEventsPartitions = fe; exports.addModuleForAllTenantsSQL = Ie; exports.addModuleSQL = he; exports.addTablePartitions = ye; exports.addTenantForAllModulesSQL = Ne; exports.addTenantSQL = Pe; exports.appendEventsSQL = ve; exports.appendToStream = _e; exports.assertSQLQueryResultMatches = pt; exports.createEventStoreSchema = X; exports.defaultPostgreSQLOptions = It; exports.defaultTag = O; exports.documentDoesNotExist = de; exports.documentExists = rt; exports.documentMatchingExists = le; exports.documentsAreTheSame = it; exports.documentsMatchingHaveCount = st; exports.emmettPrefix = x; exports.eventInStream = dt; exports.eventsInStream = Et; exports.eventsTable = r; exports.eventsTableSQL = ue; exports.expectPongoDocuments = gn; exports.expectSQL = bn; exports.getPostgreSQLEventStore = Nt; exports.globalNames = Xn; exports.globalTag = _; exports.handleProjections = D; exports.newEventsInStream = Cn; exports.pongoMultiStreamProjection = lt; exports.pongoProjection = mt; exports.pongoSingleStreamProjection = Pn; exports.postgreSQLProjection = Q; exports.postgreSQLRawBatchSQLProjection = vt; exports.postgreSQLRawSQLProjection = $n; exports.readStream = Re; exports.sanitizeNameSQL = Se; exports.schemaSQL = C; exports.streamsTable = s; exports.streamsTableSQL = Te; exports.subscriptionsTableSQL = ge;
 //# sourceMappingURL=index.cjs.map